Advance Programming Language Concepts

Abstract
This documentation will discuss about the two applications. The first application is detecting
Steganography (hidden messages) in images and implemented by using Haskell. To design and
implement of all image processing steps and detection processes use the features of functional
programming and provide the ability of reusability and future enhancement.
The other application is providing details of the Solar system using prolog programming language.
The concepts and features of logical programming languages are used to design and implement
that application.

1

Advance Programming Language Concepts
Table of Contents
Abstract.............................................................................................................................1
List of Figures ..................................................................................................................3
1 Functional Programming.................................................................................................5
1.1 Introduction...............................................................................................................5
1.2. Scope.....................................................................................................................5
1.3 Assumptions.............................................................................................................6
1.4 Flow of the application.............................................................................................6
1.5 Functional Programming Features...........................................................................7
1.6 Screens..................................................................................................................13
1.7 Test Plans.............................................................................................................18
1.7 Source Code..........................................................................................................19
2 Logical Programming....................................................................................................31
2.1 Introduction.............................................................................................................31
2.2 Scope....................................................................................................................32
2.3 Assumptions..........................................................................................................32
2.4 Logical Programming Features..............................................................................33
Facts............................................................................................................................33

2

Advance Programming Language Concepts

List of Figures
Figure 1: Main Menu........................................................................................................14
Figure 2: Image Gallery...................................................................................................15
Figure 3: Select LSB Tool................................................................................................15
Figure 4: Detect Hidden Messages.................................................................................16
Figure 5: User Manual.....................................................................................................17
Figure 6: Exit....................................................................................................................17
Figure 7: Query 1.............................................................................................................40
Figure 8:: Query 2............................................................................................................40
Figure 9:Query 3..............................................................................................................40
Figure 10:Query 4............................................................................................................40
Figure 11;:Query 5...........................................................................................................41
Figure 12:Query 6............................................................................................................41
Figure 13:: Query 7..........................................................................................................41
Figure 14: Query 8...........................................................................................................41
Figure 15:Query 9............................................................................................................41
Figure 16:Query 10..........................................................................................................42
Figure 17:Query 11..........................................................................................................42
Figure 18:Query 12..........................................................................................................42
Figure 19:Query 13..........................................................................................................42
Figure 20:Query 14..........................................................................................................42
3

Advance Programming Language Concepts
Figure 21::Query 16.........................................................................................................42
Figure 22:Query 17..........................................................................................................43
Figure 23:Query 19..........................................................................................................43
Figure 24:Query 20..........................................................................................................43
Figure 25:Query21...........................................................................................................43
Figure 26:Query22...........................................................................................................43

4

Advance Programming Language Concepts

1 Functional Programming
1.1 Introduction

The functional programming paradigms are purely based on mathematical discipline. Collection of
functions made up the whole program. Also not like the imperative programming languages, those
are avoided the side effects.
In this application detect the hidden massages inside the images using Haskell functions. It holds
the five images with the hidden messages. To represent the images use the concept of pixels. Each
pixel includes the binary value of R G B colors. Likewise hold the several pixel data to represent
the images. Then provide the several Steganalysis tools to user to select one of the tools for the
detection process. Finally hidden message will be detecting according to the selected tool.
The following are the functional features that applied in this application.

Create user defined data type called Image to store images.

Store images as a list of triples.

ASCII values of each letter hold as integer (binary) values.

Therefore words are representing in a list of integer values.

Use pure functions to each step.

Use higher order functions to combine useful pure functions.

Use IO programs to provide the sequence of the application.

Divide the application in to several modules to increase the readability and allow for future
enhancement.

1.2. Scope

Users only be able to use the images that listed in the application.
5

Advance Programming Language Concepts

Only can use the characters of ‘A-J’ of the alphabet.

Users only be able to use the Steganalysis LSB tools which listed in the application.

1.3 Assumptions

Images are including with the hidden messages.

Messages will only contain the letters up to ‘J’.

The stated ASCII values are same as the Unicode character values.

Every pixel’s LSB of R, G, B holds the secret message.

Messages are hidden from the beginning to the end continuously in the image.

1.4 Flow of the application

2. Create user defined data type called as Image to store images.
6

Advance Programming Language Concepts
3. Define ASCII values for characters.
4. User will be able to select an image among the list of images.
5. Then separate the R, G, B color values of selected image.
6. Then require selecting a Steganalysis LSB tool.
7. According to the selected tool, take only the list of values of the corresponding color.
8. Then split out the all values and get as the one value (in to one list).
9. Filter the LSB values in to a separate list from the splitted list.
10. Then combine separated filtered value into group of five elements (size of the one character).
11. Then check whether those values are valid ASCII codes according to the given character
ASCII codes.
12. After checking the validness of the ASCII values, convert that values into its corresponding
characters.
13. Then display the hidden message.
14. In this application provide user manual instructions to avoid the user confusion. It explains step
by step how to execute the application.
15. Finally terminate the program.

1.5

Functional Programming Features

User define data types
Name

Type

Usage
7

Advance Programming Language Concepts

Image

[(Int, Int, Int)]

Store the images.

Pure functions
Function

Type

Usage
Separate the R, G, B color values into

separateColors

Image  ([Int],[Int],[Int])

separate lists.
[(Int, Int, Int)]  ([Int],[Int],[Int])
Filter only the red color values.
(based on input value)

getRvalue

Int  ([Int],[Int],[Int])  [Int]
([Int],[Int],[Int])  [Int]
([11100],[00110],[11000])[11100]
Filter only the green color values.

getGvalue

Int  ([Int],[Int],[Int])  [Int]

([Int],[Int],[Int])  [Int]
([11100],[00110],[11000])[00110]
Filter only the green color values.

getBvalue

Int  ([Int],[Int],[Int])  [Int]

([Int],[Int],[Int])  [Int]
([11100],[00110],[11000])[10100]
Split the individual values into a list.

splitValue

Int  [Int]
11100  [1,1,1,0,0]

8

Advance Programming Language Concepts
Get the final bit value.
getLSB

[Int]  [Int]
[10001,11110,11111]  [1,0,1]

isElement

Checking that given element is

Int  Bool

existing or not.
Converting the integer values into

binaryToChar

their corresponding characters.

Int  Char

User defined higher order functions
Function

Type

Usage
Take the splitValue function (split
individual values) and the required
integer list as parameters and split all
the values in to one list.

splitValues

(Int  [Int]) [Int]  [Int]
[11111,10000,10101] 

[1,1,1,1,0,0,0,1,0,1,0,1]
Take each 5th element from the splitted
list in to separate list. Get
getNth

(Int  [Int]  [Int])  Int 

getAboveNth function and splitted list

[Int]  [Int]

as inputs.
[1,1,1,1,1,0,0,0,0,0]  [1,0]
9

Advance Programming Language Concepts
Check the combined values are related
checking

(Int  Bool)  [Int]  [Int]

to the letters’ ASCII codes. Get
isElement function (check with
individual value) and list as inputs.

Built-in functions and higher order functions
Function

Type

Usage

map

(a  b)  [a]  [b]

concatMap

(a  [b])  [a]  [b]

unzip3

[(a, b, c)]  ([a], [b], [c])

Apply some action for all elements in
the list.

Same as the map and combine all
resulted values together.

Separate the triple into their individual
lists.
Take input value (integer value n) and

take

Int  [a]  [a]

a list and get the first n elements in to
another list.

drop

Int  [a]  [a]

concat

[[a]]  [a]

Drop the elements until given (index)
number and place in a separate list.

Combine the list of list of value into
one list.

10

Advance Programming Language Concepts
Convert string type value into another

read

String  a

show

a  String

Convert any type value in to a string.

Type

Usage

type

Primitive recursion
Function

Take set of values according to given
index value.
getAboveNth

Int  [Int]  [Int]
3 [1,1,1,0,0,0,1,0,1] [1,1,1],[0,0,0],
[1,0,1]
Take the last bit value of every

getLSB

individual value.

[Int]  [Int]

[11110,10001,11111]  [0,1,1]
Creates the groups of splitted
elements.
First take the first five element
(character ASCII size) and then drop
groupSpliter

those values from the list and check

[Int]  [Int]

for next five elements. Likewise it will
repeat the same process until list
become empty.
[1,1,0,1,1,1,0,0,1,0]  [1,1,0,1,1],
[1,0,0,1,0]
11

Advance Programming Language Concepts
Check first combined value is related
to the letters’ ASCII codes. And then
checking

(Int  Bool)  [Int]  [Int]

it will check for whole lists elements.
[11111,100001]  11111 = ‘A’
100001 = ‘J’

binaryToString

[Int]  String

Check whether the first value is
related to some ASCII code and if
exists, display that character. This will
process until list become empty.
[11111,100001]  11111 = ‘A’
100001 = ‘J’
“AJ”

IO Functions
Name

Type

Usage

askUser

IO ()

Provide all the functionalities of input
output operations.

Modules
Name

Type

Usage

common

Common.hs

Keep all common pure functions,
higher order functions and primitive
recursion which required for this
12

Advance Programming Language Concepts

application.

images

Images.hs

Keep all images.

Keep all pure functions, higher order
steganalysis

Steganalysis.hs

functions and primitive recursion
which required for steganalysis section
(detecting section).
Keep the interface (main menu) with

main

Main.hs

IO functions to provide the sequence
of the program.

1.6

Screens

Main menu

13

Advance Programming Language Concepts

Figure 1: Main Menu

This is the main menu of this application. This will provide the ability to select an option at a time.

Image Gallery

14

Advance Programming Language Concepts

Figure 2: Image Gallery

Application will display the images after selecting option 1. User must require toselect an image to
run the application.

Select LSB Tool

Figure 3: Select LSB Tool

After selecting option 2, steganalysis LSB tools will be displayed. User must require selecting one
of the tools to detect the hidden message.
15

Advance Programming Language Concepts

Delete Hidden messages

Figure 4: Detect Hidden Messages

After selecting steganalysis LSB tool, application will be detect the hidden message and displays it.

User Manual

16

Advance Programming Language Concepts

Figure 5: User Manual

If select option 4, user will be able to see the instruction of the application.

Exit

Figure 6: Exit

Application will be terminated after completing all the processes.

17

Advance Programming Language Concepts

1.7 Test Plans

Test Case number

Expected output

Actual output

Main module

Application should display the Display the menu (Steganalysis
main menu.
If

user

software).

selects

option

1, Display the images with the menu

required to display all the name “image gallery”.
images.

Display the LSB tools.

If user selects option 2,
required to display all the LSB
Displays “Successfully detected!!”

detection tools.
If

user

selects

option

3,

required to display the hidden

message and shows the detected
message.

message.
Displays the software instructions
If

user

selects

required

to

option

display

4,
the

with

the

menu

name

“instructions”.

software instructions.
Terminate the application.
If

user

required

selects
to

terminate

application.

Image module

option

5,
the

(Therefore main module work
properly).

If user selects option 1, all the Displays all the images.
18

Advance Programming Language Concepts
images should be displayed.

(Therefore image module work
properly).

Common module

Application should be navigate Application is navigates properly.
correctly.

(Therefore functions which under
this modules work properly).

Steganalysis module

Application should be able to Displays the hidden message with
display the hidden message.

the message

of

“Successfully

detected!!”
(Therefore functions which under
this modules work properly).

1.7

Source Code

Main.hs
module Main where

19

Advance Programming Language Concepts
import Char
import Images
import Steganalysis
import Common

main=do askUser

askUser :: IO ()
askUser
= do putStrLn " "
putStrLn "(Detecting Steganography (hidden messages) in Images) "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn "\t \t******************************"
putStrLn "\t \t** STEGANALYSIS SOFTWARE **"
putStrLn "\t \t**

**"

putStrLn "\t \t******************************"
putStrLn " "
putStrLn " "
putStrLn "\t \t [1] Select Image "
putStrLn " "
putStrLn "\t \t [2] Select LSB tool "
putStrLn " "
putStrLn "\t \t [3] Detect Hidden message "
putStrLn " "
putStrLn "\t \t [4] User Manual "
putStrLn " "
putStrLn "\t \t [5] Exit "
putStrLn " "

20

Advance Programming Language Concepts
putStrLn " "
putStrLn "\t \t Please enter your choice: "
choice1 <- getLine
putStrLn " "
do
if(choice1=="1")
then
do putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn "\t \t******************************"
putStrLn "\t \t**

IMAGE GALLARY

putStrLn "\t \t**

**"

putStrLn "\t \t******************************"
putStrLn " "
putStrLn " "
putStrLn "\t \t [a] Image1 "
putStrLn " "
putStrLn "\t \t [b] Image2 "
putStrLn " "
putStrLn "\t \t [c] Image3 "
putStrLn " "
putStrLn "\t \t [d] Image4 "
putStrLn " "
putStrLn "\t \t [e] Image5 "
putStrLn " "
putStrLn " "
putStrLn "\t \t Please enter your choice: "

21

**"

Advance Programming Language Concepts
choice2 <- getLine
return choice2
putStrLn "Press any key to contiune "
var <- getLine
askUser
putStrLn " "

do

if(choice2=="a")
then
do let im = image1
--print im
return im
putStrLn " "

else if(choice2=="b")
then
do let im = image2
--print im
return im
putStrLn " "

else if(choice2=="c")
then
do let im = image3
--print im
return im
putStrLn " "

22

Advance Programming Language Concepts
else if(choice2=="d")
then
do let im = image4
--print im
return im
putStrLn " "

else
do let im = image5
--print im
return im
putStrLn " "

else if(choice1=="2")
then
do putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn "Please select LSB Steganography Tool: "
putStrLn " "
putStrLn " "
putStrLn "\t \t [1] Stego one bit RED color "
putStrLn " "
putStrLn "\t \t [2] Stego one bit GREEN color "
putStrLn " "
putStrLn "\t \t [3] Stego one bit BLUE color "

23

Advance Programming Language Concepts
choice3 <- getLine
putStrLn "Press any key to contiune "
var <- getLine
askUser
putStrLn " "

do

if(choice3=="1")
then
do let get_red = getRvalue
--print get_red
return get_red
putStrLn" "

else if(choice3=="2")
then
do let get_green = getGvalue
--print get_green
return get_green
putStrLn" "
else

do let get_blue = getBvalue
--print get_blue
return get_blue
putStrLn" "

else if(choice1=="3")
then

24

Advance Programming Language Concepts
do putStrLn " "
let separate_colors = separateColors image1
let get_red = getRvalue 25 separate_colors
let split_values = splitValues splitValue get_red
--print split_values
let lsb = getNth getAboveNth 5 split_values
--print lsb
let combine = groupSpliter lsb
--print combine
let chk = checking isElement combine
--print chk
let binary_to_string = binaryToString chk
--print binary_to_string
putStrLn "Successfully detected!! "
putStr "Hidden message is:"
print binary_to_string
putStrLn " "
putStrLn "Press any key to contiune "
var <- getLine
askUser
putStrLn " "

else if(choice1=="4")
then
do putStrLn " "
putStrLn " "
putStrLn " "
putStrLn "\t \t******************************"
putStrLn "\t \t**

INSTRUCTIONS

25

**"

Advance Programming Language Concepts
putStrLn "\t \t**

**"

putStrLn "\t \t******************************"
putStrLn " "
putStrLn " "
putStrLn "\t \t 1. First you need to select a image "
putStrLn " "
putStrLn "\t \t 2. Then select a LSB tool,which you like to apply for detection "
putStrLn " "
putStrLn "\t \t 3. After that software will be detect the hidden message for you (only if
exist)"
putStrLn " "
putStrLn "\t \t 4. You need to select option 5 to terminate the program "
putStrLn " "
putStr "\t \t 5. Make sure not to change the sequnce of the program.you have to obey the
instruction. "
putStrLn "otherwise software can be currpted."
putStrLn " "
putStrLn "Press any key to contiune "
var <- getLine
askUser
putStrLn " "

else
do putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " "
putStrLn " \t \t Thank you for using!!"
putStrLn " "

26

Advance Programming Language Concepts

images.hs
module Images where

type Image= [(Int,Int,Int)]

image1 :: Image
image2 :: Image
image3 :: Image
image4 :: Image
image5 :: Image

image1
=
(11011,10001,10011),

[(10001,10001,10101),(11000,10010,10000),(11100,10100,11110),(11110,10000,10100),
(11111,10001,10101),(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),

(11110,11010,10000),
(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),(10001,11001,10001),
(10111,10001,11111),
(11001,10011,10001),(11101,10101,11111),(11111,10001,10101),(11011,10001,10011),
(10001,11101,11111),
(10101,11101,10111),(10011,10011,10101),(11001,11001,10111),(11001,10001,10101),
(11001,10011,11101)]

image2
=
(11111,10111,11011),

[(11001,10001,10111),(11011,10001,10011),(11101,10111,11111),(10100,10100,11100),
(11111,10001,10011),(10001,10101,10011),(10010,10010,10100),(10001,11001,10001),

(10111,10001,11111),
(10001,10001,10101),(11001,10011,10001),(11101,10101,11111),(11111,10001,10101),
(11011,10001,10011),

27

Advance Programming Language Concepts
(11011,10101,10001),(11111,10111,11011),(11111,10001,10101),(10001,10101,10011),
(10011,10011,10101),
(11001,11001,10111),(11001,10001,10101),(11001,10011,11101),(11001,11111,10101),
(11101,10101,11001)]

image3
=
(11001,10011,10001),

[(10011,10111,11111),(11110,10000,10100),(11111,10001,10011),(10101,11101,10111),
(11001,10011,10001),(11101,10101,11111),(11111,10001,10101),(11010,10000,10010),

(10000,11100,11110),
(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),(11111,11011,10001),
(10001,11101,11111),
(11111,10001,10101),(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),
(11111,11011,10001),
(10101,11001,10011),(10101,10111,11111),(11111,10111,11011),(11111,10001,10101),
(10111,11111,10001)]

image4
=
(10011,10111,11111),

[(10101,11101,10111),(10011,10011,10101),(10100,10100,11100),(11000,10010,10000),
(10101,11101,10111),(10010,10010,10100),(11000,11000,10110),(11001,10001,10101),

(11001,10011,11101),
(11111,10001,10101),(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),
(11111,11011,10001),
(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),(10001,11001,10001),
(10111,10001,11111),
(11001,11001,10111),(11001,10001,10101),(11001,10011,11101),(11001,11111,10101),
(11101,10101,11001)]

image5
=
(10010,10010,10100),

[(11011,10101,10001),(11111,10111,11011),(11110,10000,10100),(10000,10100,10010),
(11111,10001,10101),(11110,10000,10010),(10100,11100,10110),(10100,10100,11100),

(11110,10110,11010),
(11011,10101,10001),(11111,10111,11011),(11111,10001,10101),(10001,10101,10011),
(10011,10011,10101),
(10011,10111,11111),(11111,10001,10101),(11111,10001,10011),(10101,11101,10111),
(11001,10011,10001),

28

Advance Programming Language Concepts
(11111,10001,10011),(10001,10101,10011),(10011,10011,10101),(11111,11011,10001),
(10001,11101,11111)]

common.hs
module Common where
splitValues ::(Int -> [Int])-> [Int] -> [Int]
splitValues f x = concatMap f x
splitValue :: Int -> [Int]
splitValue 0 = []
splitValue x = splitValue (x `div` 10) ++ [x `mod` 10]
getAboveNth:: Int -> [Int] -> [Int]
getAboveNth _ [] = []
getAboveNth n xs = head xs : getAboveNth n (drop n xs)
getNth :: (Int -> [Int] -> [Int]) -> Int -> [Int] -> [Int]
getNth f n = f n . drop (n-1)
getLSB :: [Int] -> [Int]
getLSB [] = []
getLSB (x:xs) = (x `mod` 2) : getLSB xs
groupSpliter ::[Int]->[Int]
groupSpliter []=[]
groupSpliter xs = toSingleNum (take 5 xs):(groupSpliter (drop 5 xs))
where toSingleNum ys = read $ concat $ map show ys
isElement :: Int -> Bool
isElement x | x==11111 || x==11110 || x==11101 || x==11011 || x==10111 || x==11100 || x==11001 || x==10011 ||
x==11000 || x==10001 = True
|otherwise

= False

checking :: (Int -> Bool) -> [Int] -> [Int]
checking a [] = []
checking f (x:xs)

29

Advance Programming Language Concepts
| f x = x : checking f xs
| otherwise = []
binaryToString :: [Int] -> String
binaryToString [] = []
binaryToString (x:xs) = (binaryToChar) x : binaryToString xs

binaryToChar :: Int -> Char
binaryToChar x | x == 11111 = 'A'
| x == 11110 = 'B'
| x == 11101 = 'C'
| x == 11011 = 'D'
| x == 10111 = 'E'
| x == 11100 = 'F'
| x == 11001 = 'G'
| x == 10011 = 'H'
| x == 11000 = 'I'
| x == 10001 = 'J'
|otherwise = ' '

Steganalysis.hs

module Steganalysis where
import Images
separateColors :: Image -> ([Int],[Int],[Int])
separateColors x = unzip3 x

getRvalue :: Int -> ([Int],[Int],[Int]) -> [Int]
getRvalue n (xs,_,_) = take n xs

30

Advance Programming Language Concepts
getGvalue :: Int -> ([Int],[Int],[Int]) -> [Int]
getGvalue n (_,ys,_) = take n ys

getBvalue :: Int -> ([Int],[Int],[Int]) -> [Int]
getBvalue n (_,_,zs) = take n zs

2 Logical Programming
2.1 Introduction

Logical paradigms are based on the basic facts and rules relations according to the problem
domain. Therefore those are seems less natural in more general areas of computation. Collection of
facts and rules are made up the whole program and required to generate queries to run the program.
This application is about the solar system. At the beginning, enter the basic details of the solar
system as facts in to the application. Then user will be able to ask questions about the solar system
using queries.
The following are the logical features that applied in this application.

Create different kind of facts, such as simple facts, facts with one argument, facts with two
arguments and facts with more arguments.
31

Advance Programming Language Concepts

Create conditional facts using rules.

Finally provide the answers according to related queries.

2.2 Scope

Due to large scale of the solar system, provide only planets details.

Facts and rules are containing only the basic details.

2.3 Assumptions

User will be generating queries according to the pre-defined details.

Entered details are based on true details.

32

Advance Programming Language Concepts

2.4 Logical Programming Features

Facts

Simple facts
Fact

Explanation

solar_system_is_elliptical_in_shape.

Solar system is elliptical in shape.

the_Sun_is_in_the_center_of_the_solar_system.

The Sun is in the center of the solar
system.

our_solar_system_is_always_in_motion.

Our solar system is always in motion.

the_Sun_is_the_biggest_object_in_our_solar_system.

The Sun is the biggest object in our solar
system.

solar_system_is_more_than_4_billion_years_old.

Solar system is more than 4 billion years
old.

33

Advance Programming Language Concepts

Facts with Arguments
Fact

explanation

planet(mercury).

Mercury is a planet.

planet(venus).

Venus is a planet.

planet(earth).

Earth is a planet.

planet(mars).

Mars is a planet.

planet(jupiter).

Jupiter is a planet.

Facts with two arguments
Fact

explanation

planet_of(mercury,solar_system).

Mercury is a planet of solar system.

similar(venus,earth).

Venus is similar to the earth.

calledAs(mars,red_planet).

Mars is called as red planet.

moons(fobos,dimos,mars).

fabos and dimos are the moons of mars.

Facts with more arguments
Fact

explanation

planets(mercury,venus,earth,mars,ju All those are planets.
piter,saturn,uranus,neptune,pluto).

Variables and Unification
Fact

explanation

brightest(sun,solar_system).

Sun is the brightest of the solar system.
34

Advance Programming Language Concepts
planet(1,mercury,days_88

planet(num,name,revolution around sun,revolution around

,days_59 ,no_natural_planets).

own,no of satellit)

Rules
Rule

explanation

If ,
high_temperature(sun).

high temperature in sun.

high_temperature(venus).

high temperature in venus.

high_temperature(jupiter).

high temperature in jupiter.

impossible_to_live(X):- high_temperature(X).

if high temperature (in some
planet), impossible to live.
if impossible to live, because of no

no_oxygen(X):- impossible_to_live(X).

no_water(X):-

oxygen.

no_oxygen(X).

if no oxygen, there is no water.

no_oxygen(X).
no_oxygen(X).
no_oxygen(X).

If,
temp_high(saturn).

high temperature in saturn.
35

Advance Programming Language Concepts
oxy_less(pluto).

no oxygen in pluto.

oxy_less(saturn).

no oxygen in Saturn.

wat_less(mars).

no water in mars.

wat_less(saturn).

no water in Saturn.

cant_live_in(Y):- temp_high(Y), oxy_less(Y), wat_less(Y). impossible to live in some planet
if, is high temperrature `and`, no
oxygen `and`, no water .
If,
high_temp(jupiter).

high temperature in jupiter.

high_temp(venus).

high temperature in venus.

oxy_no(mars).

no oxygen in jupiter.

oxy_no(jupiter).

no oxygen in venus.

wat_no(venus).

no water in venus.

wat_no(mars).

no water in mars.

impossible_to_live_in_planet(Z):- high_temp(Z); oxy_no(Z);

impossible to live in some planet

wat_no
(Z).

if, is high temperrature `or`
no oxygen `or` no water.

wat_no(Z).
wat_no(Z).

If,
bigger_than(earth,mercury).

earth is bigger than mercury.
36

Advance Programming Language Concepts
bigger_than(mercury,pluto).

mercury is bigger than pluto.

bigger_than(saturn,earth).

saturn is bigger than earth.

bigger_than(earth,pluto).

earth is bigger than pluto.

biggest(X,Y):- bigger_than(X,Z), bigger_than(Z,Y).

if x > z and z > y ---> x > y

smallest(Y,X):-

biggest

(X,Y). if x is biggest when compare to the
y, then y become the smallest.

biggest(X,Y).

If,
closer(sun,mercury).

mercury is closer to sun.

closer(mercury,venus).

venus is closer to mercury.

closer(venus,earth).

earth is closer to venus.

beyond(X,Y):- closer(X,A),closer(A,B),closer(B,Y).

if x >> y --> X,A,B,...Y

beyonds(X,Y):-closer(X,Z),closer(Z,Y).

if X > Z , Z > Y --> X > Y

can_see(X) :-

people can see x, if x must be a
planet

(X),

closer

(X,

planet(X),
planet(X),

Queries
37

earth).

planet and closer to the earth.

Advance Programming Language Concepts
Queries for simple facts
Queries

result

?-solar_system_is_elliptical_in_shape.

true.

?-the_Sun_is_in_the_center_of_the_solar_system.

true..

?-our_solar_system_is_always_in_motion.

true.

?-the_Sun_is_the_biggest_object_in_our_solar_system.

true.

?-solar_system_is_more_than_4_billion_years_old.

true.

Queries for Facts with Arguments
Queries

result

?-planet(mercury).

true.

?-planet(venus).

true.

?-planet(star).

false.

?-planet(astroid).

false.

Queries for Facts with two Arguments
Queries

result

?-planet_of(mercury,solar_system).

true.

?-similar(venus,earth).

true.

?-bigger(jupiter,mars).

false.

?-moons(fobos,dimos,saturn).

false.

Queries for Facts with more Arguments
Queries

result
38

Advance Programming Language Concepts
?-planets(mercury,venus,earth,mars,jupiter,saturn,uranus,neptune,pluto).

true.

?-planets(mercury,venus,earth,mars,jupiter,saturn,uranus,neptune,star).

false.

?-planets(astroid,venus,earth,mars,jupiter,saturn,uranus,neptune,pluto).

false.

?-planets(astroid,venus,earth,mars,satellite,saturn,uranus,neptune,pluto

false.

Queries for Variables and Unification
Queries

result

?- brightest(Who,solar_system).

Who = sun.

?- planet(1,Which_is_first,days_88 ,days_59 ,no_natural_planets).

Which_is_first

=

mercury.
?- planet(2,venus,Rev_around_sun,days_243,no_natural_planets).

Rev_around_sun

=

days_225.
?- planet(3,earth,year_1,Rev_around_own,one_natural_planets).

Rev_around_own

=

hrs_24.
?- planet(4,mars,year_2,hrs_25,Howmay_natural_planets).

Howmay_natural_planets
= two_natural_planets.

Queries for Rules
Queries

result

?- high_temperature(X).

sun; venus; jupiter

?- high_temperature(venus).

true.

?- impossible_to_live(pluto).

false.

?- impossible_to_live(X).

X = sun; x = venus; x = jupiter.

?- no_oxygen(X).

X = sun; x = venus; x = jupiter.

?- cant_live_in(Y).

Y = saturn.

?- cant_live_in(saturn).

true.

?- cant_live_in(pluto).

false.
39

Advance Programming Language Concepts
?- impossible_to_live_in_planet(Z).

Z =jupiter; Z = venus; Z = mars

?- impossible_to_live_in_planet(mars).

true

?- impossible_to_live_in_planet(earth).

false.

Screen Shorts
1. solar_system_is_elliptical_in_shape.

Figure 7: Query 1

2. the_Sun_is_in_the_center_of_the_solar_system.

Figure 8:: Query 2

3. planet(mercury).

Figure 9:Query 3

4. planet(venus).

Figure 10:Query 4

5. planet_of(mercury,solar_system).
40

Advance Programming Language Concepts

Figure 11;:Query 5

6. similar(venus,earth).

Figure 12:Query 6

7. planet_of(X,solar_system).

Figure 13:: Query 7

8. similar(venus,X).

Figure 14: Query 8

9. planets(mercury,venus,earth,mars,jupiter,saturn,uranus,neptune,pluto).

Figure 15:Query 9

10. planets(A,B,earth,mars,jupiter,saturn,uranus,neptune,pluto).

41

Advance Programming Language Concepts

Figure 16:Query 10

11. planets(A,venus,earth,mars,jupiter,saturn,uranus,neptune,pluto).

Figure 17:Query 11

12. brightest(Who,solar_system)

Figure 18:Query 12

13. planet(1,Which_is_first,days_88 ,days_59 ,no_natural_planets).

Figure 19:Query 13

14. high_temperature(X).

Figure 20:Query 14

15. impossible_to_live(sun).

Figure 21::Query 16

42

Advance Programming Language Concepts
16. impossible_to_live(X).

.

Figure 22:Query 17

17. cant_live_in(Y).

Figure 23:Query 19

18. cant_live_in(saturn).

Figure 24:Query 20

19. impossible_to_live_in_planet(Z).

Figure 25:Query21

20. biggest(X,pluto).

Figure 26:Query22

43

Advance Programming Language Concepts

44

Sign up to vote on this title
UsefulNot useful