Theoretical Basis of Language System with State Constraints

Susumu Yamasaki

HCI Group, Department of Computer Science, Okayama University, Tsushima-Naka, Okayama, Japan

Keywords:

Programming Language, Algebraic Expression, State Constraint System.

Abstract:

This paper presents theoretical basis of a language system whose program is described as algebraic expres-

sions and implemented as abstract state machine. The behaviors of the described expressions may be captured

(with their models) as causing sequences for state transitions, where composition and alternation for state tran-

sitions are mechanized in algebraic structure. Monitoring facilities to the language system may be described

with state concepts, as well. With respect to intuitionistic logic and logical program containing negatives,

Heyting algebra expressions are taken rather than already established nonmonotonic reasoning programs with

negations, where 3-valued domain may be of use for the undeﬁned to be allowable such that positives and

negatives may be consistently evaluated, instead of rigid 2-valued settlements. We may have a standard form

of Heyting algebra expressions in accordance to logical and AI programming, where the expressions are con-

strained with states. The states may be regarded as environmental conditions or objects as in object-oriented

programming. As regards 3-valued models of given expressions, monotonic mapping cannot be in general as-

sociated with, but some ways are presented to approximate ﬁxed points of a mapping for the given expression.

Then the formal description of programs may be given with reference to state transitions, which is thought of

as proposing a language system structure.

1 INTRODUCTION

As resources, programming languages are very sig-

niﬁcant in complex information systems. Whether

they are viewed from abstract or concretized points,

they must also involve communication functions not

only with other programming environments but also

with human to the network. In this paper, we have a

consistent theory for programming method of a lan-

guage system based on abstract state machine, which

program implementation is made with and its alge-

braic basis is specialized to, possibly for application

to complex information systems. The abstract notion

of states is assumed, from resource environments of

programmable and communicative capabilities. The

backgrounds of this paper are common to those which

the paper on modal mu-calculus extension (S. Ya-

masaki, 2020) refers to, such that this paper may aim

at the programming language system primarily based

on abstract state machine.

As backgrounds of operational ways to capture

programs with, we have seen on abstract state ma-

chine structures and actions that: (i) by composed

actions as programs in dynamic logic, acting and

sensing failures, and actions to generate and execute

plans are discussed as advanced works (Spalazzi and

Traverso, 2000). (ii) the action is formulated as a

key role in strategic reasoning of abstract state ma-

chine, applicable to AI systems. (iii) actions are also

captured in logical systems, as in the papers (Gior-

dano et al., 2000; Hanks and McDermott, 1987). (iv)

the procedural action is expressed by denotational ap-

proach in the book (Mosses, 1992), while the pro-

cedural method is essentially operational, that is, for

programs to be implementable. (v) the actions may be

reviewed, with functional programs (Bertolissi et al.,

2006). (vi) algebraic systems of abstract state ma-

chine are discussed, in the literature (Droste et al.,

2009; Reps et al., 2005). (vii) regarding structure

of streams possibly caused by abstract state machine,

there is the note (Rutten, 2001).

As programming systems applied to communica-

tions, we pay attention to the frameworks:

(a) AI developments are presented on the basis of log-

ics with knowledge (Reiter, 2001). Based on be-

liefs and intentions, modal operations are used to

represent mental states (Dragoni et al., 1985).

(b) Regarding communication technology, argumen-

tation is sometimes popular, in terms of non-

classical negation, and abstract attack and defense

are regarded as elements of the argumentation

concepts rather than communications by algebraic

Yamasaki, S.

Theoretical Basis of Language System with State Constraints.

DOI: 10.5220/0009385100800087

In Proceedings of the 5th International Conference on Complexity, Future Information Systems and Risk (COMPLEXIS 2020), pages 80-87

ISBN: 978-989-758-427-5

processes. From model theoretic views, the argu-

mentation may be expressed by means of 3-valued

logic to the semantics for defeasible reasonings

to implement argumentation (Governatori et al.,

2004).

Merro and Nardelli, 2005) have been studied from

the views to make communication environments

clearly described, as well as process algebras

(Hennessy and Milner, 1985; Kucera and Esparza,

2003; Park, 1970).

(d) The modal mu-calculus, related to abstract state

machine, contains a ﬁxed point notation by which

actions and communications are satisﬁed with

given conditions. The modal logic with ﬁxed

point operator is reﬁned in the paper (Venema,

2006). The papers (Dam and Gurov, 2002; Kozen,

1983) are classical enough to formulate the proof

systems with ﬁxed points and their approxima-

tions.

With reference to such works, this paper deals

with theoretical basis of:

(1) a language system based on algebraic expressions

whose models may cause state transitions, for a

programing system with state constraint designs

to implement and to describe complex AI facili-

ties and reasonings compactly, and

(2) Heyting algebra expressions, to be able to involve

a treatment of negation (for expressiveness as a

program), different from the one of default nega-

tion often used in AI researches.

For the construction of complex information sys-

tems by means of programming in this language sys-

tem, some monitoring functions are to be facilitated,

where the descriptions of functions may be made with

abstract states constraining programming. Communi-

cation and behavior facilities are involved in abstract

monitoring. In this paper, communicative and behav-

ioral means are regarded as abstract functions. As

well as functional aspects from descriptions on ab-

stract state machine, algebraic expressions as designs

(programs) contain logical aspects.

Compared with default or defeasible logic in AI

programming,

(i) defeasibility is beforehand assumed in the given

rules, to be more complex, but

(ii) the plain program consisting of rules by Heyt-

ing algebra expressions is simpler without treating

ambiguity of rules containing default negation.

The paper is organized as follows. Section 2 is

concerned with Heyting algebra expressions, and with

the standardization of expressions, closely related to

logical programming with default negation and to

state constraint programming. Section 3 discusses

the 3-valued models of algebraic expressions. Section

4 presents a language system with monitor facilities,

whose program can be interpreted in terms of models

for Heyting algebra expressions and by structures for

the implementation aspects as well as for monitoring.

Concluding remarks and references to related topics

on knowledge are mentioned in Section 5.

2 UNIVERSAL EXPRESSIONS

FOR LOGICAL DESIGNS

Regarding operations, processing, or program imple-

mentation, we need logical descriptions of designs

for functions with reference to complex systems and

their dynamic workings. Logical programming has

been studied for universal tools of design, where ﬁrst-

order predicate calculus is primary. If an inﬁnite set

of proposition letters is allowable, the propositional

logic may simulate the ﬁrst-order calculus with Her-

brad base. Heyting algebra may be a basis for propo-

sitional logic to be as universal as the ﬁrst-order cal-

culus, where Heyting algebra is more ﬂexible than

Boolean algebra. In thses senses, we here examine

Heyting algebra for expressions concerning descrip-

tions of design ideas. Because of the treatment for

negatives of Heyting algebra expressions, some theo-

retical basis is motivated to be made clear, for us to

formulate a language system containing algebraic ex-

pressions as programs of a language.

2.1 Algebraic Expressions

Heyting algebra (HA) (A,

,⊥,>) equipped with

the partial order v and an implication ⇒ is assumed

as follows:

(i) ⊥ and > are the least and the greatest elements

of the algebra (set) A, respectively, with respect

to the partial order v.

(ii) the join

and meet

are deﬁned for any two

elements of A.

(iii) as regards the implication ⇒,

c v (a ⇒ b) iff a

c v b.

The element a ⇒ ⊥ is denoted as “not a” for a ∈ A,

where not ⊥ = > and not > = ⊥.

The expression F (over the underlined set A of

the algebra), which is here paid attention to, is of the

form:

j∈ω

.. .

⇒ l

)

Theoretical Basis of Language System with State Constraints

where l

denotes a or a ⇒ ⊥ for a ∈ A. The expres-

sion F is regarded as modelling some programing.

Related Programming:

A “logic program” with respect to its Herbrand

base may be regarded as containing the predicate pr

(with or without “

∼

” as a procedure) preceded by the

conjunction of:

,. .. , pr

(as a procedural body)

for pr

,. .. , pr

(predicates or their negations).

Example 1. Assume the following propositional for-

mula F:

(bird

∼

abnormal ⇒ f ly)

(⇒ bird)

( f ly ⇒

∼

abnormal)

( f ly ⇒

∼

observed)

(

∼

f ly ⇒ observed),

where, for the propositions bird, abnormal, f ly,

observed,

(a)

(meet) is used as and,

(b)

∼

(default negation) is assigned in place of not,

(d) the parentheses are used to have priorities of (log-

ical) connectives.

Then it might be expected that (a) with the assertion

of bird and by default negation of abnormal, f ly may

be implied, and (b) the bird is not observed as default,

however, it may not be, because of the part (of some

ambiguity with other parts), f ly ⇒

∼

abnormal, such

that neither f ly nor default negation of abnormal can

be implied so that it may be unknown for bird not to

be observed.

This example presents a common view on logic

programs with answer set programming (Osorio et al.,

2004) or on defeasible logic (Governatori et al.,

2004), where the negation may be taken as default

with the procedure of “negation as failure”, which

means that the procedural proof failure of a proposi-

tion may infer its negation (Kowalski and Toni, 1996).

In a language system of this paper, it is a strict

negation that the algebraic expression models, rather

than default negation, even in considerations on 3-

valued model of expressions, with reference to the im-

plication of the algebra. The 3-valued model of ex-

pressions contains more complexity than the 2-valued

model, however, theoretical interests are involved

for representation simplicity and algebraic treatments,

which motivate us to take it for design of language

system, as well as for solutions to the theories. We

then make summaries of the theories, assuming in

Heyting algebra that (a) the implication is based on

Heyting algebra, and (b) the evaluation of not a (with

respect to the value of a for a ∈ A) follows the rule:

a not a

1 0

1/2 0

0 1

As is well known, we note some algebraic proper-

ties on the HA with parentheses of operation-priority

representation, for the next subsection:

((a ⇒ b)

(b ⇒ c)) v (a ⇒ c),

a v not (not a),

not (a

b) = not a

not b.

2.2 Transformation of Expressions

In an Heyting algebra (A,

,⊥, >), any expression

derives some expression Ex

of the form (referred

to in Section 2.1 and as in standard form):

j∈ω

.. .

⇒ y

where l

and l

are an expression a or not a (denoting

a v ⊥), for a ∈ A, such that

v Ex

By the method which is as below shown with

proof, we may have such a standardization to trans-

form a given expression Ex

to Ex

. If there is some

model of Ex

in 3-valued domain, then it may be also

the model of Ex

. In this sense, the expression Ex

worthwhile being obtained, as a standard form.

Transformation of Expressions:

In what follows, the cases (of what the given ex-

pression exp

is) are presented such that transforma-

tions may be available, where X, Y , and Z stand for

some (sub)expressions. There is a relation: exp

exp

, between a replacing expression exp

and a re-

placed one exp

in each transformation of the items

(1) – (8).

(I) For the right side of the primary operation ⇒,

the items (1) – (4) are applied:

(1) X ⇒ (Y ⇒ Z) to be replaced by: X ⇒ (Y

Z).

(2) X ⇒ (Y

Z) to be replaced by: X ⇒ Y or X ⇒

(3) X ⇒ (Y

Z) to be replaced by:

(X ⇒ Y )

(X ⇒ Z).

(4) X ⇒ not Y to be replaced by:

(Y ⇒ y)

(X ⇒ not y)

COMPLEXIS 2020 - 5th International Conference on Complexity, Future Information Systems and Risk

for an arbitrarily and newly chosen element y

∈ A (or variable y over A).

(II) For the left side of the primary operation ⇒, the

items (5) – (8) are applied.

(5) (X ⇒ Y ) ⇒ Z to be replaced by:

(X ⇒ Y )

(> ⇒ Z)

for the top element >.

(6) (X

Y ) ⇒ Z to be replaced by:

not (not X

not Y ) ⇒ Z.

(7) (X

Y ) ⇒ Z to be replaced by:

((x

y) ⇒ Z)

(X ⇒ x)

(Y ⇒ y)

for arbitrarily and newly chosen x, y ∈ A.

(8) not X ⇒ Y to be replaced by:

(x ⇒ X)

(not x ⇒ Y )

for an arbitrarily chosen x ∈ A.

Proposition 1. Given an expression Ex

, an expres-

sion Ex

of standard form is derived by the Transfor-

mation of Expressions such that Ex

v Ex

Proof. By the recursive applications of (I) (contain-

ing the items (1) – (4)), reducing the right side of

the implication ⇒ to the simple form (which is rep-

resented as a or not a for a ∈ A), we may have an

expression exp of the form

⇒ x

where each X

is a (sub)expression and each x

is a or

not a (for a ∈ A). By the recursive applications of (II)

(containing the items (5) – (8) with the (I) case from

the item (5) or (8)) to each X

⇒ x

of exp, reducing

the left side of the implication ⇒, we may have an

expression Ex

of standard form. This comes from

the reason for structure of expression form, why the

application of (I) case from the item (5) or (8) is avail-

able in (II) case, for the (sub)form not to be the simple

but to be of less length.

The model of the expression F of standard form is

discussed in the next section.

3 3-VALUED MODEL OF

EXPRESSIONS

We have known applicable ﬁxed point as model of the

expression F, over the 3-valued domain {0,1/2,1}.

With the set A for an expression F of standard form

(where p ⇒ ⊥ is denoted by not p), a mapping

: 2

× 2

→ 2

× 2

) = (I

has been noted with order of componentwise subset

inclusion:

contains p such that p is obtained by:

∃(p

.. . ∧ p

not p

i+1

.. .not p

⇒ p) in F.

∀p

∈ I

(1 ≤ k ≤ i), ∀p

∈ J

(i + 1 ≤ k

≤ j),

contains q such that q is obtained by:

∀(q

.. .

,not q

i+1

,. .. ,not q

⇒ q) in F.

∃q

(1 ≤ k ≤ i). q

∈ J

, or

∃q

(i + 1 ≤ k

≤ j). q

6∈ J

, or

∃(q

.. .

,not q

i+1

,. .. ,not q

⇒ not q) in F.

∀q

(1 ≤ k ≤ i). q

6∈ J

, and

∀q

(i + 1 ≤ k

≤ j). q

∈ J

If Ψ

(I, J) ⊆

(I, J) (with the componentwise set in-

clusion ⊆

) and I ∩ J =

0, then (I, J) can be a model

of F. Since the mapping Ψ

is not monotonic, the

method by (pre-)ﬁxpoint of Ψ

is not always avail-

able as a modelling of the given expression F.

Because of the negation interpretation, some

approximations cannot be taken, even with mono-

tonic mappings (the least ﬁxed points of which are

worthwhile referring to), extended from those already

established by A. van Gelder et al. (1991) and by M.

Fitting (1985).

In what follows, we suppose the set A (for HA

expressions) and the expression F of standard form.

We now have a procedure with respect to con-

struction of some model (I, J), where Ψ

(I, J) ⊆

(I, J), and an adjusting (as another procedure) to be

sound to the constructed model. Making use of “nega-

tion as failure” rule with its variants, we take the no-

tations as follows:

(1) With a given expression F of standard form,

query of the sequence “X?” is assumed, where X =

;. .. ; y

(n ≥ 0) with y

being a or not a for a ∈ A and

with the concatenation operation “;” (which is treated

), where in case of “n = 0”, X is null (the empty

query). A sequence query may be denoted as y;X ?

(with y being b or not b for b ∈ A, and with X a se-

quence query), or Y ; X ? with Y and X queries.

(2) The notations

[X? succ], [X? f ail], and [X ? no f ail]

stand for the returns of the Procedure to say that

(i) the query X? is a success, (ii) the query X? is

a failure, and (iii) the query X? is not a failure,

respectively.

Theoretical Basis of Language System with State Constraints

Procedure (for Model of an Expression):

The routines are inductively deﬁned with queries

to be a success, a failure, and not a failure.

(1) [null? suc].

(2) [x; X? suc], if x = a (for a ∈ A) and there is

Y ⇒ x in F such that [Y ;X ? suc].

(3) (a) [x; X? suc], if [a? f ail] for x = not a, and

[X? suc].

(b) [x; X ? suc], if [a? f ail] for x = not a

where there is Y ⇒ x in F with [Y ? no f ail],

and [X? suc].

(4) [x; X? f ail], if there is no part with x = a ∈ A

being the right side of “⇒” in F, or [X? f ail].

(5) (a) [x; X? f ail], if x = a (a ∈ A) such that

[Y ? f ail] for any Y (where Y ⇒ x in F), or

[X? f ail].

(b) [x; X ? f ail], if x = a such that [Y ? no f ail]

for some Y where Y ⇒ not a in F, or [X? f ail].

(6) [x; X? f ail], if x = not a such that [a? no f ail],

or [X? f ail].

Example 2. Assume the algebraic expression in cor-

respondence with the propositional formula F in Ex-

ample 1. Let the expression be referred to by F, with

the same name of the formula.

(bird

not abnormal ⇒ f ly)

(> ⇒ bird)

( f ly ⇒ not abnormal)

( f ly ⇒ not observed)

(not f ly ⇒ observed).

Following the Procedure, we can see that:

[bird? suc] and [ f ly? no f ail] −→

[abnormal? f ail],[ f ly? suc],[observed? f ail], or

[bird? suc], and [abnormal? no f ail] −→

[ f ly f ail],[abnormal? suc],[observed? suc].

where “−→” means inferences for the successes and

failures of queries.

Now let the pair (I, J) be deﬁned by:

I = {a ∈ A | [a? suc]},J = {b ∈ A | [b? f ail[}.

The Procedure works to construct a pair (I, J) so

that (a) if [a? suc] then a ∈ I, and (b) if [a? f ail] then

a ∈ J. For such a constructed pair (I, J) of the expres-

sion F over the set A, we would like to see that (I, J)

is just a model in the following sense.

Proposition 2. Assume the pair (I, J) constructed by

the Procedure for a HA expression F of standard form

such that

I = {a ∈ A | [a? suc]},

J = {b ∈ A | [b? f ail[}.

If I ∩ J =

0, then the pair (I, J) is a model of F.

Proof. The reason comes from the case examinations

by induction on constructions of the Procedure, for

the effects of the mapping Ψ

for Ψ

(I, J) ⊆

(I, J):

We show on the case of I ∩ J =

0 that if we let

(I, J) = (I

) then (I

) ⊆

(I, J).

(1) Let a ∈ I

. (i) It follows with respect to the map-

ping of Ψ

that there may be some Y ⇒ a in F such

that (i) Y = null, or (ii) with b ∈ I for any b in Y , and

with c ∈ J for any not c in Y .

In case of (i), [a? suc] and a ∈ I. In case of (ii), by

the Procedure construction, (a) [b? suc] for b ∈ I and

(b) [not c? suc] for c ∈ J, respectively, in Y such that

[a? suc]. Note by the Procedure to simulate the map-

ping Ψ

that [not c? suc] comes from [c? f ail] for

c ∈ J, or from ∃Z. (Z ⇒ not c and [Z? no f ail]) for

c ∈ J. Thus a ∈ I. Finally, if a ∈ I

then a ∈ I.

(2) Let a ∈ J

. Both the cases (i) and (ii) (as below)

comes from that (I

) can be obtained with the ap-

plication of Ψ

to (I, J), and derives that a ∈ J:

(i) If there is no part Y ⇒ a in F so that the mapping

may assume a ∈ J

. It follows by the Procedure

that [a? f ail]. That is, a ∈ J.

(ii) (a) If ∀Y. (Y ⇒ a entails that there is some b in Y

such that b ∈ J, or some not c in Y such that c 6∈ J),

then a ∈ J

. By the Procedure, [b? f ail] (b ∈ J) and

[c? no f ail] (c 6∈ J) causes [a? f ail]. Thus a ∈ J. (b)

If ∃Y . (Y ⇒ not a in Y, where any b 6∈ J or any not c

for c ∈ J in Y ), then a ∈ J

. By the Procedure, if b 6∈ J

then [b? no f ail], and if c ∈ J then [c? f ail]. It follows

that: [Y ? no f ail] such that [a? f ail]. Thus a ∈ J.

The procedure contains rules regarded as variants

of negation as failure:

(i) [not a? suc], if [a? f ail].

(ii) [not a? f ail], if [a? no f ail].

To make the procedure free from the rule

[a? no f ail] or [Y ? no f ail] (for a query sequence Y ),

we may make the procedure adjusted into a simpler

version with assumption that [a? no f ail] is reasoned

by [a? suc]. Therefore classical “negation as failure”

may be adopted:

(a) a query not a? is a success, if [a? f ail], and

(b) a query not a? is a failure, if [a? suc].

COMPLEXIS 2020 - 5th International Conference on Complexity, Future Information Systems and Risk

4 LANGUAGE SYSTEM

In this section, we have a formal aspect of a language

for its program to be realized as abstract state

machine and as a semiring to explain an algebraic

structure for implementation of the program. The

state constraint system may contain query processing

in database, algebraic expression of strategies, and

program implementation assigned to states (likely

reﬂecting environments, situations and designing

concepts as classes).

States s

Processing queriy

query

Strategy expression

expression

Implementation program

program

Having an outlook on the state constraint system,

queries, algebraic expressions, and programs are re-

garded as synonymous for database, strategic plans

and designs, which are constrained at states, that is,

are compiled to the states. The formal description of

such a state constrained framework as a language sys-

tem is now given theoretically.

As regards the state constraint system, the expres-

sions for design may be considered as resources at

states, where the design idea based on some allow-

able assumptions for inferences related to implemen-

tations like query processing, strategic reasoning and

program execution. In this sense, not only technical

views but also social views may be contained in the

concepts of state constraints. Therefore the state con-

straint language system should be studied for compact

manners free from complex design methods.

4.1 State Constraint Language

The expression as in Example 1 may be separated into

two expressions with states (for constraints), where

the default negation is replaced by the negation not in

Heyting algebra.

Example 3. We now have the next forms from the

expression in Example 2, by separating F into 2 parts

constrained by 2 states, respectively:

(bird

not abnormal ⇒ f ly)

(> ⇒ bird)

( f ly ⇒ not abnormal) B s

( f ly ⇒ not observed)

(not f ly ⇒ observed) B s

(i) At the state s

, there may be 2 models:

({bird, f ly},{abnormal}),

({bird,abnormal},{ f ly}),

possibly causing the state transition to s

(ii) At the state s

, 2 models as follows may be taken:

({observed}, { f ly}), ({ f ly}, {observed}),

causing the state transition to s

There are 2 cases: (a) If bird is not abnormal at

state s

, then f ly is assigned to 1 so that the bird may

f ly, and the state s

transfers to the state s

. After

the state transition from s

to s

, the bird may be

“not” observed, that is, “not observed”, at the state

, where it remains at the state s

(that is, the state

transition from s

to s

may be assumed).

(b) If bird is abnormal at state s

, then f ly is

assigned to 0 so that bird may not f ly, from where

the transition to s

occurs. At state s

, bird may be

observed with not f ly, where the state s

transits to

itself.

As in Example 3, we may have a sequence of a

program.

: body

: .. .; s

: body

(n ≥ 0).

Each body

(of such a program part “s

: body

”)

may contain algebraic expressions with states (to be

transited to). That is,

.. .

not b

.. .

not b

⇒ y

)

(to a state s

)

for y

= c or not c with c ∈ A.

Such analysis motivates a language, whose pro-

gram is, in Backus-Naur Form, inductively repre-

sented.

prog ::= null

prog

| prog; s : body

body ::= null

body

| body; exp B s

exp ::= > | exp

( f orm)

f orm ::= le f t ⇒ a | le f t ⇒ not a

le f t ::= > | le f t

a | le f t

not a

where the parentheses are used to denote the scope

such that:

(i) s is a state variable.

(ii) a is a variable over the domain (set) of the given

algebra, possibly denoting the greatest element

> and the least element ⊥.

(iii) the symbol

means a “meet” in the underlined

lattice (algebra), and the symbol B stands for “a

transition to”.

(iv) null

prog

and null

body

denote the empty se-

quences for the deﬁnitions of a program prog

and a body body (constrained by a state), re-

spectively, where the semicolon “;” denotes an

operation of concatenation.

Theoretical Basis of Language System with State Constraints

Conditional Statements:

Whether it is in the manner of functional or pro-

cedural programming, the program contains the con-

ditional statement:

if C

then A

else if C

then A

.. .

else if C

then A

where C

, ..., C

are conditions, and A

, ..., A

are

some functions (commands). It can be represented by

the HA expression:

⇒ a

)

.. .

(not c

.. .

not c

n−1

⇒ a

)

where c

and a

are algebraic elements in accordance

with conditions C

and function implementations A

(successful, undeﬁned or failed), respectively, for

1 ≤ i ≤ n.

Monitoring to Programming:

For the construction of complex systems, monitor-

ing is to be facilitated to the language constrained by

states, as in the paper on modal mu-calculus extension

(S. Yamasaki, 2020).

(a) Conditioning Including Awareness – With a func-

tion condi, conditioning is regarded as a mapping

of each state to a set of logical formulas, where

logical formulas represent conditions. It involves

awareness to (programming and network) envi-

ronments, condi : S → 2

, where S is the set of set

variables in this language, and Φ stands for the set

of logical formulas.

(b) Communication – With a relation commu, com-

munications between states (that is, state con-

strained programs) may be described. It may fol-

low the process algebra (Milner, 1999) as estab-

lished principle. By the set S of states, the relation

is just as commu ⊆ S × S.

programming with interaction to the human side,

a function of each state to a set of behaviours is

required: behav : S → 2

, where S is the set of

states, and B is a set of behaviours.

4.2 Structure for State Transition

Concerning algebraic aspects of behaviours for the

program of this form, regular language properties

may be abstracted, rather than context-free language

properties as in the paper (Paulo and Jose, 2017). A

star semiring structure is given by the method (S. Ya-

masaki, in COMPLEXIS 2017).

Given an expression F (which is “exp” of

“exp B s” over the set A) at some state to “body” in a

program, we may have a pair (I,J) ∈ 2

× 2

, which

can be a 3-valued model of exp.

With Heyting Algebra (HA) expressions to a con-

straint state, models of expressions can be considered

with state transitions.

HA expression 3-valued model, selected

exp (as a program) (I, J) (a pair)

Example 4. Given a program of Example 3, if we take

models:

({bird, f ly},{abnormal}) at state s

, and

({ f ly}, {observed}) at state s

then a sequence, constructed by a concatenation of

bird (at state s

) with f ly (at state s

may be taken with consistency to both negations of

abnormal (at state s

) and observed (at state s

With the domain A, we can have denumerable ex-

pressions F

, F

, .. ., the models of which may be:

), (I

), .. . ∈ 2

× 2

On such pairs causing state transitions based on

the program description (of body at some state), we

consider the operations of (a) the composition of

models, and (b) the alternation to models.

As regards sequences causing state transitions, we

know formality of automata, having a quintuple

A = hS, Σ,δ, s

as a machinery, where:

(i) S is a ﬁnite set of states.

(ii) Σ is an alphabet.

(iii) δ : S × Σ → S is a mapping.

(iv) s

∈ S is the initial state.

(v) S

⊆ S is a ﬁnal subset.

The mapping δ is extended to the one

δ : S ×Σ

→

S for the set Σ

of ﬁnite sequences concatenated from

the symbols of Σ such that:



δ(s,nulll

) = s, with the null sequence null

δ(s,uσ) = δ(

δ(s,u), σ) for u ∈ Σ

and σ ∈ Σ.

We then have the set of sequences

= {w ∈ Σ

∗

δ(s

,w) ∈ S

}

as accepted by the machinery A . In this case, we

regard Σ as {(I,J) | (I,J) is a model of some exp}.

COMPLEXIS 2020 - 5th International Conference on Complexity, Future Information Systems and Risk

5 CONCLUSION

The primary result of this paper is a formal system

formulation to a programming language, where the

program (constrained by states) is algebraic expres-

sions, applicable to analysis, and expected to design

of complex AI. The language may contain state con-

straint programming and monitoring facilities. The

implementations (accompanying state transitions) are

globally captured with star semiring structure. The

system realizes abstract state machine with:

(a) Compact and formal description of state con-

straint programs,

(b) Model theories of algebraic expressions as pro-

grams, and

quences (associated with models).

From the views of AI and software technologies

to complex systems with human, this idea based on

abstract state machine may allow human computer in-

teraction (HCI) to determine state transitions. The in-

teraction can be involved in the program containing

some expressions at states to the language system of

this paper with some algebraic elements.

As a logical framework, this paper gives a theoret-

ical basis with compact description, but its practical

aspects or applications are to be examined for further

studies. A complex AI to be interactive with cogni-

tive facilities should be examined. As a software tech-

nology, semantics for implementation of programs of

this language system is to be made clearer even in 3-

valued logic, with respect to object-oriented program-

ming (where the object class may be regarded as a

state). Compared with sophisticated works on logi-

cal frameworks in logic and computation possibly for

AI, there are concepts and ideas on knowledge. “Dis-

tributed knowledge” is discussed (Naumov and Tao,

2019), with quantiﬁed variables of quantiﬁes ranging

over the set of agents. Concerning applications of

the second-order predicates to knowledge, the paper

(Kooi, 2016) contains the concept of knowing. Dis-

tributive knowledge processing is of more complexity

even for the state constrained programs.

REFERENCES

Bertolissi, C., Cirstea, H., and Kirchner, C. (2006).

Expressing combinatory reduction systems

derivations in the rewriting calculus. Higher-

Order.Symbolic.Comput., 19(4):345–376.

Cardelli, L. and Gordon, A. (2000). Mobile ambients. The-

oret.Comput.Sci., 240(1):177–213.

Dam, M. and Gurov, D. (2002). Mu-calculus with ex-

plicit points and approximations. J.Log.Comput.,

12(1):119–136.

Dragoni, A., Giorgini, P., and Seraﬁni, L. (1985).

Mental states recognition from communication.

J.Log.Program., 2(4):295–312.

Droste, M., Kuich, W., and Vogler, H. (2009). Handbook of

Weighted Automata. Springer.

Giordano, L., Martelli, A., and Schwind, C. (2000).

Ramiﬁcation and causality in a modal action logic.

J.Log.Comput., 10(5):625–662.

Governatori, G., Maher, M., Autoniou, G., and Billington,

D. (2004). Argumentation semantics for defeasible

logic. J.Log.Comput., 14(5):675–702.

Hanks, S. and McDermott, D. (1987). Nonmonotonic logic

and temporal projection. Artiﬁ.Intelli., 33(3):379–

412.

Hennessy, M. and Milner, R. (1985). Algebraic laws for

nondeterminism and concurrency. J.ACM, 32(1):137–

161.

Kooi, B. (2016). The ambiguity of knowability.

Rev.Symb.Log., 9(3):421–428.

Kowalski, R. A. and Toni, F. (1996). Abstract argumenta-

tion. Artiﬁ.Intell.Law, 4(3-4):275–296.

Kozen, D. (1983). Results on the propositional mu-calculus.

Theoret.Comput.Sci., 27(3):333–354.

Kucera, A. and Esparza, J. (2003). A logical view-

point on process-algebraic quotients. J.Log.Comput.,

13(6):863–880.

Merro, M. and Nardelli, F. (2005). Behavioral theory for

mobile ambients. J.ACM., 52(6):961–1023.

Milner, R. (1999). Communicating and Mobile Systems:

The Pi-Calculus. Cambridge University Press.

Mosses, P. (1992). Action Semantics. Cambridge University

Press.

Naumov, P. and Tao, J. (2019). Everyone knows that

some knows: Quantiﬁers over epistemic agents.

Rev.Symb.Log., 12(2):255–270.

Osorio, M., Navarro, J. A., and Arrazola, J. (2004). Appli-

cations of intuitionistic logic in answer set program-

ming. TLP, 4(3):325–354.

Park, D. M. R. (1970). Fixpoint induction and proof of pro-

gram semantics. Machine Intelligence, 5:59–78.

Paulo, R. and Jose, J. (2017). Instrumenting a context-free

language recognizer. In Proc. of 19th ICEIS - Vol. 2,

pages 203–210.

Reiter, R. (2001). Knowledge in Action. MIT Press.

Reps, T., Schwoon, S., and Somesh, J. (2005). Weighted

pushdown systems and their application to interproce-

dural data ﬂow analysis. Sci.Comput.Program., 58(1-

2):206–263.

Rutten, J. (2001). On Streams and Coinduction. CWI.

Spalazzi, L. and Traverso, P. (2000). A dynamic logic

for acting, sensing and planning. J.Log.Comput.,

10(6):787–821.

Venema, Y. (2006). Automata and ﬁxed point logic: A coal-

gebraic perspective. Inf.Comput., 204(4):637–678.

Theoretical Basis of Language System with State Constraints