DEV Community: Abolfazl Mohammadijoo

Building a Four-Bar Linkage Mechanism Simulator in Haskell

Abolfazl Mohammadijoo — Tue, 09 Jun 2026 21:01:42 +0000

Most developers know Haskell as a language for functional programming, type safety, compilers, parsers, and beautiful mathematical abstractions.

But can Haskell also be used to build an interactive engineering simulator?

That was the motivation behind my project:

Four-Bar Mechanism Haskell Simulator

Repository:

https://github.com/mohammadijoo/Four-Bar-Mechanism-Haskell

This project is a browser-backed desktop-style GUI application written in Haskell. It visualizes, classifies, and animates a planar four-bar linkage mechanism, which is one of the most classical mechanisms in mechanical engineering, kinematics, and machine design.

The GUI is built with Threepenny-GUI, so the interface runs in a local browser window, while the mathematical model and mechanism logic remain written in Haskell.

For me, the interesting part was not only drawing a moving linkage. It was about connecting mechanism design theory, computational geometry, and functional programming in one small educational simulator.

What is a four-bar linkage?

A four-bar linkage is a closed-loop mechanical system made from four rigid links connected by four revolute joints.

In this project, the four links are:

Symbol	Name	Description
`g`	Ground link	Fixed distance between pivots A and B
`a`	Input link	Rotating link from A to moving pivot C
`b`	Output link	Link from fixed pivot B to moving pivot D
`f`	Floating link / coupler	Link connecting moving pivots C and D

The fixed pivots are placed at:

A = (0, 0), B = (g, 0)

The input link rotates by angle $α$ . Therefore, point C can be computed directly as:

C = (a cos α,; a sin α)

Point D is more interesting.

It must satisfy two geometric distance constraints:

∣ D - C ∣ = f

∣ D - B ∣ = b

So the simulator solves the position of point D using a circle-intersection method.

One circle is centered at C with radius f.
The other circle is centered at B with radius b.

Where those two circles intersect, the mechanism can close.

That is the basic geometric heart of the simulator.

Why four-bar linkages matter

Four-bar mechanisms appear in many real mechanical systems.

Some examples include:

Application	Role of the four-bar idea
Engines	Converts rotating and oscillating motion
Suspension systems	Guides constrained motion
Robotic grippers	Creates controlled opening and closing paths
Pumps	Converts rotary motion into reciprocating motion
Walking mechanisms	Generates repeated leg-like motion
Windshield wipers	Converts motor rotation into sweeping motion
Machine tools	Produces repeatable constrained motion

A four-bar linkage is simple enough to understand visually, but rich enough to teach real mechanism design concepts.

That is why it appears so often in mechanical engineering and machine design courses.

Mobility of the mechanism

A planar mechanism can be analyzed using the Kutzbach-Grübler mobility equation.

M = 3 (n - 1) - 2 j_{1} - j_{2}

where:

Symbol	Meaning
`M`	Mobility / degrees of freedom
`n`	Number of links
`j1`	Number of lower pairs, such as revolute joints
`j2`	Number of higher pairs

For an ideal planar four-bar linkage:

n = 4, j_{1} = 4, j_{2} = 0

Substituting these values gives:

M = 3 (4 - 1) - 2 (4) - 0

M = 9 - 8 = 1

So a four-bar linkage has exactly one degree of freedom.

This means that once the input angle is chosen, the rest of the linkage configuration is determined by the loop-closure constraints, except for the selected assembly branch.

That is a nice result: one input motion drives the whole mechanism.

The implemented geometric model

The simulator computes the mechanism position from the link lengths and the input angle.

First, the distance between B and C is calculated:

d = ∣ B - C ∣

For the mechanism to close, the two circles must intersect. The assembly condition is:

∣ f - b ∣ \leq d \leq f + b

If this condition is not satisfied, there is no real point D, and the mechanism cannot be assembled at that input angle.

When the condition is satisfied, there are usually two possible solutions for point D. These represent the two assembly branches of the mechanism.

In the GUI, the user can switch between these two branches using the Flip branch button or the F key.

This is one of the parts I like most about the project: the animation is not just a pre-drawn visual effect. The simulator actually solves the linkage geometry.

Grashof condition

One of the most important ideas in four-bar linkage design is the Grashof condition.

Let the four link lengths be sorted as:

s \leq p \leq q \leq l

where s is the shortest link and l is the longest link.

The Grashof index is:

G = s + l - p - q

The classification is:

Condition	Meaning
`G < 0`	Grashof mechanism
`G = 0`	Change-point mechanism
`G > 0`	Non-Grashof mechanism

This matters because a Grashof mechanism usually has at least one link that can make a full rotation relative to the ground.

In practical terms, this helps answer an important design question:

Can the input link rotate continuously, or will it only rock back and forth?

That is exactly the kind of question a mechanism designer needs to answer early.

Validity index

The simulator also checks whether the mechanism is physically assemblable.

The validity index is:

V = l - s - p - q

A valid four-bar mechanism must satisfy:

V \leq 0

If:

V > 0

then the longest link is longer than the sum of the other three links. In that case, the loop cannot close.

So the simulator reports not only the motion type, but also whether the chosen link lengths describe a valid mechanism.

This is useful because a random set of four link lengths does not always produce a real four-bar linkage.

Full linkage state classification

The simulator computes three excess values:

T_{1} = g + f - b - a

T_{2} = b + g - f - a

T_{3} = f + b - g - a

The signs of these values help classify the detailed linkage state.

The GUI then displays the simplified motion type:

Classification	Meaning
`crank-crank`	Both relevant links can rotate fully
`crank-rocker`	Input rotates fully, output rocks
`rocker-crank`	Input rocks, output rotates fully
`rocker-rocker`	Both links oscillate

This turns the project into more than a moving diagram. It becomes a small mechanism classification tool.

Why use Haskell?

Haskell is probably not the first language most people would choose for a mechanical simulator.

Python, MATLAB, C++, JavaScript, or Julia are more common choices for engineering applications.

But that is exactly why this project was interesting.

Haskell is very good at separating pure mathematical logic from side-effecting application code.

In this project, the mechanism model is separated into a pure Haskell module:

src/FourBar.hs

This module contains the core mechanism logic, including:

Linkage
Pose
excesses
grashofIndex
validityIndex
classifyMotion
basicMotionState
solvePose
nearestValidAlpha

The GUI and event loop are handled separately in:

app/Main.hs

This separation is important.

The mechanism solver can later be reused in tests, command-line tools, notebooks, optimization programs, or even a web backend.

So Haskell helps keep the engineering model clean, testable, and reusable.

That is one of the main reasons I enjoyed building this project.

Threepenny-GUI and the browser-backed interface

The project uses Threepenny-GUI.

Threepenny-GUI allows a Haskell program to create an interface that is rendered in a web browser. The application starts a local GUI server, and the user opens:

http://127.0.0.1:8023

The browser is the visual layer, but the application logic remains in Haskell.

The GUI includes:

Feature	Description
Link sliders	Change `g`, `a`, `b`, and `f` interactively
SVG drawing	Renders the mechanism as scalable browser graphics
Play / Pause	Starts and stops the animation
Flip branch	Switches between the two assembly solutions
Reset	Restores the default mechanism
Angle display	Shows live alpha and beta values
Classification panel	Shows Grashof, validity, and crank/rocker state
Keyboard controls	Space, `F`, and `R` shortcuts

I like this architecture because it combines two worlds:

Haskell \to mechanism logic

Browser + SVG \to visual interface

Threepenny-GUI acts as the bridge between them.

SVG visualization

The mechanism is rendered using SVG.

SVG is a good fit for this kind of project because it is scalable, clean, and works naturally inside a browser interface.

The simulator draws:

fixed pivots
moving pivots
links
labels
angle arcs
the current linkage configuration

Because the GUI is browser-rendered, the interface can use HTML, CSS, fonts, and SVG while still keeping the engineering logic in Haskell.

The result is a simple but effective architecture:

Pure Haskell solver + Threepenny-GUI + SVG rendering

Repository structure

The repository is organized like this:

Four-Bar-Mechanism-Haskell/
├── app/
│   └── Main.hs
├── src/
│   └── FourBar.hs
├── resources/
│   └── fonts/
│       └── Inter-Regular.ttf
├── fourbar-linkage-threepenny.cabal
├── README.md
├── LICENSE
└── .gitignore

The most important files are:

src/FourBar.hs
app/Main.hs

FourBar.hs contains the pure mechanism mathematics.

Main.hs builds the GUI, handles events, updates the state, and renders the current mechanism as SVG.

This structure makes the project easier to understand because the engineering model is not mixed directly into the interface code.

How to run the project

First, install Haskell using GHCup.

Then clone the repository:

git clone https://github.com/mohammadijoo/Four-Bar-Mechanism-Haskell.git
cd Four-Bar-Mechanism-Haskell

Update Cabal:

cabal update

Run the simulator:

cabal run fourbar-linkage-threepenny

If the browser does not open automatically, open:

http://127.0.0.1:8023

Controls

Control	Action
Drag `g` slider	Change ground link length
Drag `a` slider	Change input link length
Drag `b` slider	Change output link length
Drag `f` slider	Change floating/coupler link length
Play / Pause	Start or stop animation
Flip branch	Switch assembly branch
Reset	Restore default mechanism
Space	Toggle Play / Pause
`F`	Flip branch
`R`	Reset

The sliders make the simulator useful for experimentation.

You can change link lengths and immediately see how the mechanism behavior changes.

That is helpful for learning because mechanism theory becomes visual.

What this project demonstrates

This project demonstrates several ideas at the same time:

Area	What the project shows
Mechanical engineering	Four-bar linkage geometry and classification
Kinematics	Loop-closure constraints and assembly branches
Computational geometry	Circle intersection for solving point D
Haskell programming	Pure modeling separated from GUI code
GUI development	Browser-backed interface with Threepenny-GUI
Visualization	SVG-based scalable mechanism drawing

For me, the most useful lesson is that Haskell can be used for more than abstract examples.

It can also be used to build small, practical, interactive engineering tools.

Possible future improvements

Some future improvements could make the simulator even more useful:

Add coupler point tracing
Plot the coupler curve
Export motion data as CSV
Add velocity and acceleration analysis
Add transmission angle plots
Add mechanical advantage visualization
Add automated tests for mechanism classification
Package the app as a standalone desktop executable

The most interesting improvement would probably be coupler curve tracing.

Many real design problems ask:

What link lengths should I choose so that a point on the coupler follows a desired path?

Adding that feature would move the project from simulation toward mechanism synthesis.

Conclusion

The four-bar linkage is simple, but it contains many important engineering ideas.

With only four links and four revolute joints, it can produce rich motion patterns and useful mechanical transformations.

In this project, I used Haskell to model the mechanism, Threepenny-GUI to build the interface, and SVG to render the animation in a browser-backed desktop-style application.

The result is a small educational simulator that connects theory, geometry, and functional programming.

Repository:

https://github.com/mohammadijoo/Four-Bar-Mechanism-Haskell

Thanks for reading.

Building a Double Pendulum Chaos Simulator in Prolog

Abolfazl Mohammadijoo — Mon, 08 Jun 2026 13:27:36 +0000

Most developers know Prolog as a language for symbolic reasoning, expert systems, search, theorem proving, and artificial intelligence. But can Prolog also be used to build a numerical physics simulator with a desktop GUI?

That was the motivation behind my project:

Prolog Double Pendulum Chaos Simulator

Repository:

https://github.com/mohammadijoo/Prolog-Double-Pendulum-Chaos-Simulator

The project is a desktop GUI application written in SWI-Prolog using the XPCE graphical toolkit. It simulates the classical double pendulum, one of the most famous examples of deterministic chaos.

The application lets the user define physical parameters such as initial angles, angular velocities, link lengths, masses, gravity, damping, numerical time step, and perturbation size. Then it animates the double pendulum and draws the trajectory of the outer endpoint.

The interesting part is that the motion is completely deterministic, but for many initial conditions it becomes visually irregular, highly sensitive, and practically unpredictable.

That is the essence of chaos.

What is a double pendulum?

A simple pendulum has one mass attached to one link. For small angles, it behaves almost like a linear oscillator. Its motion is smooth, periodic, and relatively easy to predict.

A double pendulum adds only one more link and one more mass:

Link 1 rotates around a fixed pivot.
Link 2 rotates around the end of link 1.
Each link has its own angle and angular velocity.
Gravity acts on both masses.

That small structural change is enough to make the dynamics much richer.

The state of the system can be written as:

x = [θ_{1}, θ_{2}, ω_{1}, ω_{2}]^{T}

where:

Symbol	Meaning
`theta1` / $θ_{1}$	angle of the first link
`theta2` / $θ_{2}$	angle of the second link
`omega1` / $ω_{1}$	angular velocity of the first link
`omega2` / $ω_{2}$	angular velocity of the second link

In first-order state-space form:

θ ˙_{1} = ω_{1}

θ ˙_{2} = ω_{2}

ω ˙_{1} = f_{1} (θ_{1}, θ_{2}, ω_{1}, ω_{2}, m_{1}, m_{2}, L_{1}, L_{2}, g)

ω ˙_{2} = f_{2} (θ_{1}, θ_{2}, ω_{1}, ω_{2}, m_{1}, m_{2}, L_{1}, L_{2}, g)

This means the angular accelerations depend on the current angles, angular velocities, masses, lengths, and gravity.

Why is the double pendulum chaotic?

Chaos does not mean randomness.

A chaotic system can be fully deterministic. The equations are fixed. There is no random force inside the mathematical model. But tiny differences in the starting condition can grow rapidly and produce very different future behavior.

This is called sensitive dependence on initial conditions, often described as the butterfly effect.

In this project, I added a small perturbation option so that the user can compare two nearly identical initial states:

x_{A} (0) = [θ_{1}, θ_{2}, ω_{1}, ω_{2}]^{T}

x_{B} (0) = [θ_{1} + δ, θ_{2}, ω_{1}, ω_{2}]^{T}

Here, $δ$ may be extremely small, for example:

δ = 0.0 5^{\circ}

At the beginning, both motions may look almost identical. After some time, the trajectories can separate dramatically.

That is not because the simulator is broken. It is exactly what the nonlinear dynamics predict.

The double pendulum becomes chaotic because of several factors.

1. Nonlinear trigonometric coupling

The equations contain terms like:

sin (θ_{1} - θ_{2})

cos (θ_{1} - θ_{2})

sin (θ_{1} - 2 θ_{2})

These terms couple the two links in a nonlinear way.

2. Velocity-squared terms

The accelerations contain terms involving:

ω_{12}, ω_{22}

These terms represent inertial and centripetal effects. When the pendulum moves fast, these nonlinear terms become very important.

3. Energy transfer between links

Energy can move back and forth between the two links. Sometimes the second link swings gently. Sometimes it flips rapidly. This exchange creates complex motion.

4. Bounded but irregular motion

The pendulum is physically bounded by its link lengths, but the endpoint path can become tangled and aperiodic. This is a typical sign of deterministic chaos: the motion is bounded, but it does not settle into a simple repeating pattern.

The implemented dynamic model

For angles measured from the downward vertical direction, the project uses the classical double-pendulum equations.

Define:

Δ = θ_{1} - θ_{2}

D = 2 m_{1} + m_{2} - m_{2} cos (2 θ_{1} - 2 θ_{2})

Then the angular acceleration of the first link is:

ω ˙_{1} = \frac{- g ( 2 m _{1} + m _{2} ) sin ( θ _{1} ) - m _{2} g sin ( θ _{1} - 2 θ _{2} ) - 2 m _{2} sin ( Δ ) ( ω _{22} L _{2} + ω _{12} L _{1} cos ( Δ ))}{L _{1} D} - c ω_{1}

The angular acceleration of the second link is:

ω ˙_{2} = \frac{2 sin ( Δ ) ( ω _{12} L _{1} ( m _{1} + m _{2} ) + g ( m _{1} + m _{2} ) cos ( θ _{1} ) + ω _{22} L _{2} m _{2} cos ( Δ ) )}{L _{2} D} - c ω_{2}

where:

Symbol	Meaning
$m_{1}, m_{2}$	masses
$L_{1}, L_{2}$	link lengths
$g$	gravitational acceleration
$c$	optional damping coefficient

When $c = 0$ , the system is ideal and conservative except for numerical integration error.

When $c > 0$ , a small damping term is applied.

Converting angles to Cartesian positions

To draw the pendulum, the simulator converts angular states into Cartesian coordinates.

The first bob position is:

x_{1} = L_{1} sin (θ_{1})

y_{1} = L_{1} cos (θ_{1})

The second bob position is:

x_{2} = x_{1} + L_{2} sin (θ_{2})

y_{2} = y_{1} + L_{2} cos (θ_{2})

The simulator draws the trajectory of:

(x_{2}, y_{2})

which is the endpoint of the outer link.

That endpoint trajectory is the most visually interesting part of the simulation. It often forms irregular loops, folds, and tangled paths.

Numerical integration with RK4

The system is described by nonlinear differential equations. To animate it, the simulator must repeatedly advance the state forward in time.

For this project I used the classical fourth-order Runge-Kutta method, usually called RK4.

For a state equation:

x ˙ = f (x, t)

RK4 computes:

k_{1} = f (x_{n}, t_{n})

k_{2} = f (x_{n} + \frac{h}{2} k_{1}, t_{n} + \frac{h}{2})

k_{3} = f (x_{n} + \frac{h}{2} k_{2}, t_{n} + \frac{h}{2})

k_{4} = f (x_{n} + h k_{3}, t_{n} + h)

and then:

x_{n + 1} = x_{n} + \frac{h}{6} (k_{1} + 2 k_{2} + 2 k_{3} + k_{4})

In the GUI, the user can choose the time step dt.

A smaller value such as 0.01 usually gives smoother and more accurate behavior.

A larger value such as 0.03 or 0.04 may run faster but can introduce larger numerical error.

This is especially important in chaotic systems, because numerical error can also grow over time.

Why use Prolog for this?

Prolog is usually not the first language people choose for physics simulation. Python, MATLAB, C++, Julia, or JavaScript are more common choices.

That is exactly why this project was interesting.

Prolog is a logic programming language. Instead of writing programs mainly as sequences of commands, you describe facts, rules, relations, and goals.

A Prolog predicate can describe a relationship such as:

deg_to_rad(Degrees, Radians).

or:

rk4_step(State, Params, Dt, NextState).

In this project, Prolog is used for:

simulation state management
parsing user input
numerical derivative computation
RK4 integration
GUI control logic
drawing commands
event handling
timer-based animation
logging and reset behavior

This makes the project a useful experiment in applying a symbolic/logical language to a numerical and graphical problem.

The main lesson is that Prolog is not limited to toy examples or pure symbolic AI. With SWI-Prolog and XPCE, it can also build interactive desktop applications.

SWI-Prolog and XPCE

The project uses SWI-Prolog, a mature open-source Prolog implementation.

For the GUI, it uses XPCE, the graphical toolkit available with SWI-Prolog.

XPCE provides GUI elements such as:

frames
dialogs
buttons
text fields
drawing canvases
graphical objects
timers
event messages

The simulator uses XPCE to create:

the main desktop application window
a MATLAB-like trajectory view
a CAD-like mechanism view
control fields for initial conditions
Play / Pause and Reset buttons
real-time drawing of links, bobs, pivots, grids, and trajectories

GUI concept

The GUI is divided into two main visual areas.

Left pane: trajectory view

The left side shows the endpoint trajectory. It is similar to a scientific plotting or MATLAB-style visualization.

It includes:

coordinate grid
axes
double pendulum shape
endpoint trail
energy drift information

This view emphasizes the mathematical behavior of the system.

Right pane: mechanism view

The right side shows the physical pendulum in a more mechanical or CAD-like style.

It includes:

pivot
first link
second link
first bob
second bob
current mechanism configuration

This view emphasizes the physical structure of the system.

Bottom control pane

The bottom pane contains the input fields and controls:

initial angle 1
initial angle 2
angular velocity 1
angular velocity 2
link lengths
masses
gravity
damping
perturbation
time step
maximum trail points
Play / Pause
Reset
clock
motion log

Repository structure

The repository is organized as follows:

prolog-double-pendulum-chaos-simulator/
│
├── run.pl
├── README.md
├── LICENSE
├── .gitignore
├── CONTRIBUTING.md
│
├── src/
│   ├── double_pendulum_gui.pl
│   └── double_pendulum_physics.pl
│
├── docs/
│   ├── EQUATIONS.md
│   └── DEVELOPMENT_NOTES.md
│
├── examples/
│   └── initial_conditions.txt
│
└── screenshots/
    └── .gitkeep

The two most important source files are:

src/double_pendulum_physics.pl
src/double_pendulum_gui.pl

Physics module

The physics module contains the mathematical model and numerical integration code.

Important predicates include:

deg_to_rad(+Degrees, -Radians)

Converts degrees to radians.

rad_to_deg(+Radians, -Degrees)

Converts radians to degrees.

derivatives(+State, +Params, -Derivative)

Computes the state derivative of the double pendulum.

Example state representation:

state(Theta1, Theta2, Omega1, Omega2)

Example parameter representation:

params(M1, M2, L1, L2, G, Damping)

Derivative representation:

deriv(DTheta1, DTheta2, DOmega1, DOmega2)

The RK4 integrator is exposed through:

rk4_step(+State, +Params, +Dt, -NextState)

The Cartesian position calculation is handled by:

bob_positions(+State, +Params, -X1, -Y1, -X2, -Y2)

The module also estimates total mechanical energy:

total_energy(+State, +Params, -Energy)

This helps observe numerical drift during simulation.

GUI module

The GUI module contains the XPCE interface and animation loop.

Important predicates include:

main.

which builds and opens the desktop GUI.

build_gui.

which creates the main frame, drawing canvas, text fields, buttons, labels, and layout.

toggle_simulation.

which handles Play / Pause behavior.

start_new_simulation.

which reads the input fields, builds the initial state, creates the perturbation state, creates the timer, and starts the animation.

simulation_tick.

which is called repeatedly by the XPCE timer.

Each tick performs the main animation tasks:

advance both pendulums using RK4
update the simulation clock
append new endpoint trajectory points
redraw the GUI
update logs
stop automatically after the maximum simulation time

The drawing helper predicates wrap XPCE drawing objects such as lines, circles, boxes, and text.

How to run the project

First install SWI-Prolog with XPCE support.

Clone the repository:

git clone https://github.com/mohammadijoo/Prolog-Double-Pendulum-Chaos-Simulator.git
cd Prolog-Double-Pendulum-Chaos-Simulator

Run:

swipl -q -f none run.pl

You can also start SWI-Prolog manually:

swipl

Then load and run:

?- [run].
?- main.

To verify that XPCE is available:

?- use_module(library(pce)).
true.

Suggested initial conditions

Here are some useful test cases.

Strong chaotic behavior

theta1 deg      120
theta2 deg      -10
omega1 rad/s    0.0
omega2 rad/s    0.0
L1 m            1.0
L2 m            1.0
m1 kg           1.0
m2 kg           1.0
g m/s^2         9.81
damping         0.000
perturb deg     0.05
dt s            0.02
trail points    1500

Smaller perturbation

theta1 deg      120
theta2 deg      -10
omega1 rad/s    0.0
omega2 rad/s    0.0
perturb deg     0.005
dt s            0.01

High-energy motion

theta1 deg      170
theta2 deg      80
omega1 rad/s    0.0
omega2 rad/s    0.0
perturb deg     0.05
dt s            0.01

Damped motion

theta1 deg      130
theta2 deg      -30
omega1 rad/s    0.0
omega2 rad/s    0.0
damping         0.02
perturb deg     0.05
dt s            0.02

With damping, the system eventually loses energy, but the early transient motion can still show strong sensitivity.

What this project demonstrates

This project is not just a pendulum animation.

It demonstrates several important ideas:

Deterministic chaos
The system follows exact equations, but long-term prediction becomes practically difficult.
Sensitivity to initial conditions
Very small perturbations can eventually produce very different trajectories.
Nonlinear dynamics
Trigonometric coupling and velocity-squared terms make the system behave very differently from a linear oscillator.
Numerical simulation
RK4 integration makes it possible to animate the differential equations step by step.
Prolog beyond symbolic AI
Prolog can also be used for GUI applications, numerical computation, and engineering-style educational software.
Visualization as a learning tool
Seeing the endpoint trajectory makes the concept of chaos much easier to understand than formulas alone.

Screenshots

Possible future improvements

Some possible directions for future versions:

export trajectory data to CSV
add phase-space plots
add Lyapunov exponent estimation
compare Euler, RK2, RK4, and symplectic integration
add real-time parameter sliders
add multi-pendulum ensemble visualization
add GIF/video export
add web version using Prolog backend and JavaScript frontend
add unit tests for the physics predicates
improve energy conservation diagnostics

A particularly interesting next step would be estimating the largest Lyapunov exponent. That would turn the visual idea of “nearby states separating” into a measurable quantity.

Conceptually, if two nearby trajectories separate approximately as:

d (t) \approx d (0) e^{λ t}

then $λ$ is a Lyapunov exponent.

If:

λ > 0

the system shows exponential divergence of nearby trajectories, which is a signature of chaos.

Conclusion

The double pendulum is a beautiful example of how simple mechanical components can produce complex nonlinear behavior.

Two links, two masses, gravity, and deterministic equations are enough to create motion that appears almost random.

Using Prolog for this project made it even more interesting. It shows that Prolog can be used not only for symbolic reasoning and AI-style logic programming, but also for building interactive engineering simulations with a desktop GUI.

Repository:

https://github.com/mohammadijoo/Prolog-Double-Pendulum-Chaos-Simulator

If you are interested in Prolog, numerical simulation, nonlinear dynamics, or educational engineering software, feel free to check the repository, try the simulator, and suggest improvements.

Thanks for reading.

DEV Community: Abolfazl Mohammadijoo

Building a Four-Bar Linkage Mechanism Simulator in Haskell

What is a four-bar linkage?

Why four-bar linkages matter

Mobility of the mechanism

The implemented geometric model

Grashof condition

Validity index

Full linkage state classification

Why use Haskell?

Threepenny-GUI and the browser-backed interface

SVG visualization

Repository structure

How to run the project

Controls

What this project demonstrates

Possible future improvements

Conclusion

Building a Double Pendulum Chaos Simulator in Prolog

What is a double pendulum?

Why is the double pendulum chaotic?

1. Nonlinear trigonometric coupling

2. Velocity-squared terms

3. Energy transfer between links

4. Bounded but irregular motion

The implemented dynamic model

Converting angles to Cartesian positions

Numerical integration with RK4

Why use Prolog for this?

SWI-Prolog and XPCE

GUI concept

Left pane: trajectory view

Right pane: mechanism view

Bottom control pane

Repository structure

Physics module

GUI module

How to run the project

Suggested initial conditions

Strong chaotic behavior

Smaller perturbation

High-energy motion

Damped motion

What this project demonstrates

Screenshots

Related videos

Possible future improvements

Conclusion