Logic Negation with Spiking Neural P Systems

Logic Negation with Spiking Neural P Systems Daniel Rodríguez-Chavarría1 · Miguel A. Gutiérrez-Naranjo1 · Joaquín Borrego-Díaz1 Abstract Nowadays, the success of neural networks as reasoning systems is doubtless. Nonetheless, one of the drawbacks of such reasoning systems is that they work as black-boxes and the acquired knowledge is not human readable. In this paper, we present a new step in order to close the gap between connectionist and logic based reasoning systems. We show that two of the most used inference rules for obtaining negative information in rule based reasoning systems, the so-called Closed World Assumption and Negation as Finite Failure can be characterized by means of spiking neural P systems, a formal model of the third generation of neural networks born in the framework of membrane computing. Keywords Psystems· Logic negation · Membrane computing 1 Introduction Neural networks are nowadays one of the most promising tools in computer sciences. They have been successfully applied to many real-world domains and the number of application fields is continuously increasing [15]. Beyond this doubtless success, one of the main drawbacks of such systems is that they work as black-boxes, i.e., the learned knowledge through the training process is not human-readable. Learning process in neural networks consists basically of optimizing parameters (usually a huge amount of them) guided by some type of gradient-based method and the resulting model is usually far from having semantic sense for a human researcher. In fact, the problem of explainability is becoming a new research frontier in artificial intelligence systems, even beyond machine learning [1,14]. Due to this lack of readability, new studies about the integration of neural network models (the socalled BJoaquín Borrego-Díaz [email protected] Daniel Rodríguez-Chavarría [email protected] Miguel A. Gutiérrez-Naranjo [email protected] 1Department of Computer Science and Artificial Intelligence, University of Seville, Seville, Spain connectionist systems) and logic-based systems [4,6,17,27,31,35] can shed a new light on the future development of both research areas. In this context, the computational framework known as spiking neural P systems [20,21] (SN P systems, for short) provides a formal framework for the integration of both disciplines: on the one hand, they use spikes (electrical impulses) as discrete units of information as in logic-based methods and, on the other hand, their models consist of graphs where the information flows among nodes as in standard neural network architectures. SN P systems belong to the third generation of neural network models [26], the so-called integrate-and-fire spiking neuron models [13]. The integration of logic and neural networks via spikes takes advantage from an important biological fact: all the spikes inside a biological brain look alike. By using this feature, a computational binary code can be considered: sending one spike is considered as a sign for true and if no spikes are sent, then it is considered as a sign of false. These features were exploited in [10] where SN P systems were used to bridge bioinspired connectionist systems with the semantics of reasoning systems based on logic. The main contribution of this paper is to add new elements for dealing with negation in the interplay of bridging neural networks and logic. Bridges between both areas can help to enrich each other. In this study, we go on with the approach started in [10] by focusing on logic negation. Using negation in computational logic systems is often a hard task [3] since pure derivative reasoning systems have no way to derive negative information from a set of facts and rules. This problem is solved by adding to the reasoning system a new inference rule which allows to derive negative information. In this paper, two of such inference rules are studied in the framework of SN P systems: Closed World Assumption (CWA) and Negation as Finite Failure (NFF). Loosely speaking, given a deductive database KB, CWA considers false all the atomic sentences which are not logical consequence of KB. The attempts to check whether a sentence is a logical consequence of KB or not can fall into an infinite loop, and therefore, a different effective rule is needed. Such rule is NFF. It considers false a sentence if all the attempts to prove it fail (according to some protocol). This is a quite restrictive definition of negation, but it is on the basis of many reasoning systems used in Artificial Intelligence as the Logic Programming paradigms [23] or planning systems [24]. The recent development of SN P systems involves SN P systems with communication on request [28], applications of fuzzy SN P systems [19,37], cell-like SN P systems [38], SN P systems with request rules [33], SN P systems with structural plasticity [8], SN P systems with thresholds [40] or SN P systems with rules on synapses [34] among many others. Some applications of Membrane Computing to real-life problems (including SN P systems) can be found in the literature (see, e.g., [16,41]). The paper is organized as follows: Sect. 2 recalls some basics on SN P systems and the procedural and declarative semantics of deductive databases. The following section shows how the inference rules CWA and NFF can be characterized via SN P systems. Finally, some conclusions are showed in Sect. 4. 2 Preliminaries In this section, we recall briefly some basic concepts on SN P systems and the declarative and procedural semantics of deductive databases. 2.1 Spiking Neural P Systems SN P systems were introduced as a model of computational devices inspired by the flow of information between neurons. This model keeps the basic idea of encoding and processing the information via binary events used other spiking neuron models (see, e.g., Ch. 3 in [11]). Such devices are distributed and work in a parallel way. They consist of a directed graph with neurons placed on the nodes. Each neuron contains a number of copies of an object called the spike and it may contain several firing and forgetting rules. Firing rules send spikes to other neurons. Forgetting rules allow to remove spikes from a neuron. In order to decide if a rule is applicable, the contents of the neuron is checked against a regular set associated with the rule. In each time unit, if several rules can be applied in a neuron, one of them, non-deterministically chosen, must be used. In this way, rules are used in a sequential way in each neuron, but neurons function in parallel with each other. As usual, a global clock with discrete time steps is assumed and the functioning of the whole system is synchronized. Formally, an SN P system of the degree m≥1 is a construct3 Π=(O,σ 1,σ 2,...,σ m,syn) where O={a}is the singleton alphabet (ais called spike)andσ1,σ 2,...,σ mare neurons. Each neuron is a pair σi=(ni,Ri),1≤i≤m,where: 1. ni≥0istheinitial number of spikes contained in σi; 2. Riis a finite set of rules of the following two kinds: (1) firing rules of type E/ap→aq,whereEis a regular expression over the spike a and p,q≥1 are integer numbers ; (2) forgetting rules of type as→λ, with san integer number such that s≥1; The set of synapses (edges) syn is a set of pairs syn ⊆{1,2,...,m}×{1,2,...,m}, verifying that (i,i)does not belong to sys for any i∈{1,...,m}. Let us suppose that the neuron σicontains kspikes and a rule E/ap→aqwith k≥p. Let L(E)be the language generated by the regular expression E. In these conditions, if ak belongs to L(E), then the rule E/ap→aqcan be applied. The application is performed by sending qspikes to all neurons σjsuch that (i,j)∈syn and deleting pspikes from σi(thus only k−pspikes remain into the neuron). In this case, it is said that the neuron is fired. Let us now suppose that the neuron σicontains exactly sspikes and the forgetting rule as→λ. In such case, the rule can be fired by removing all the sspikes from σi.Ifthe regular expression Ein a firing rule E/ap→aqis equal to ap, then the firing rule can be expressed as ap→aq. In each time unit, if a neuron σican use one of its rules, then one of them must be used. If two or more rules can be applied in a neuron, then only one of them is non-deterministically chosen regardless of its type. The SN P system evolves according to these type of rules and reaches different configurations which are represented as vectors Cj=(tj 1,...,tj m)where tj kstands for the number of spikes at the neuron σkin the 3In the literature, many different SN P systems models have been presented. In this paper, a simple model is considered. j−th configuration. It will be useful to consider only the first components of a configuration. Let us define Cj[1,...,n]=(tj 1,...,tj n)as the n-dimensional vector composed by the n first components of Cj. The initial configuration is the vector with the number of spikes in each neuron at the beginning of the computation C0=(n1,n2,...,nm). By using the rules described above, transitions between configurations can be defined. A sequence of transitions which starts at the initial configuration is called a computation. 2.2 Declarative Semantics of Rule-Based Deductive Databases Reasoning based on rules can be formalized according to different approaches. In this paper, propositional logic is considered for representing knowledge. Different formal representation systems where the number of available terms is finite (as those based on pairs attribute-value of first order logic representations without function symbols) can be bijectively mapped onto propositional logic systems and therefore the presented approach covers many real-life cases. Next, some basics on propositional logic are provided. Let {p1,...,pn}beasetofvariables. A literal is a variable or a negated variable. An expression L1∧···∧Ln→A,where n≥0, Ais a variable and L1,...Lnare literals is a rule. The conjunction L1∧···∧Lnis the body and the variable Ais the head of the rule. If n=0, the body of the rule is empty. A finite set of rules KBis called a deductive database. A mapping I:{p1,...,pn}→{0,1}is an interpretation, which is usually represented as a vector (i1,...,in)with I(pk)=ik∈{0,1} for k∈{1,...,n}. The interpretations I↓and I↑are defined as I↓=(0,...,0)and I↑=(1,...,1). The set of all the interpretations on a set of nvariables denote by 2n.Given two interpretations I1and I2,I1⊆I2if for all k∈{1,...,n},I1(pk)=1 implies I2(pk)=1; I1∪I2and I1∩I2are new interpretations such that (I1∪I2)(pk)=max{I1(pk), I2(pk)} and (I1∩I2)(pk)=min{I1(pk), I2(pk)}for k∈{1,...,n}. An operator S:2n→2nis monotone if for all interpretations I1and I2,ifI1⊆I2,thenS(I1)⊆S(I2).Aninterpretation Iis extended in the following way: I(¬pi)=1−I(pi)for a variable pi; I(L1∧···∧Ln)=min{I(L1),...,I(Ln)}and for a rule4 I(L1∧···∧Ln→A)=0ifI(L1∧···∧Ln)=1andI(A)=0 1 otherwise Next, we recall the notions of model and F-model of a deductive database. The concept of F-model is one of the key ideas in this paper. To the best of our knowledge, it was firstly presented in [39]. The definition used in this paper is adapted from the original one. Definition 1 Let Ibe an interpretation for a deductive database KB –Iis a model if for all rule L1∧···∧ Ln→Averifying that min i∈{1,...,n}I(Li)=1, the equality I(A)=1 holds; in other words, if I(R)=1 for all rule R∈KB. –Iis a F-model if for all rule L1∧···∧Ln→Averifying that I(A)=1, the equality max i∈{1,...,n}I(Li)=1 holds. Next example illustrates these concepts. Example 1 Let KBbe the deductive database on the set {p1,p2,p3,p4,p5,p6,p7,p8,p9} defined as follows: R1≡→p1R4≡p3∧p6→p4R7≡p6→p5R9≡p7→p2 R2≡p1→p2R5≡p4→p5R8≡p8→p9R10 ≡p9→p8 R3≡p1∧p2→p3R6≡p7→p6 4 Let us remark that, according to the definition, I (→ A) = 1 if and only if I (A) = 1. then, the interpretation represented by the vector I1=(1,1,1,0,0,0,0,0,0)is a model of KB. In this case, the rules verifying min i∈{1,...,n}I(Li)=1 are R1,R2and R3and all of them satisfies I(A)=1. The interpretations I2=(0,0,0,1,1,1,1,0,0)and I3=(0,0,0,1,1,1,1,1,1)are F-models of KB. In both cases, for all rule L1∧···∧Ln→Averifying that I(A)=1, the equality max i∈{1,...,n}I(Li)=1 holds. If we consider the interpretation I2,thenI2(p4)=I2(p5)=I2(p6)=I2(p7)=1 and all the rules with variables p4,p5,p6or p7in their heads (R4,R5and R6)verifythat there exists a variable qin the body of the rule with I(q)=1. The case of I3is analogous. In a certain sense, F-models keep a duality with respect the concept of models. If IAand IBare models, then IA∩IBis also a model and if they are F-models,thenIA∪IBis also aF-model [39]. Next, the definition of Failure Operator FKB of a deductive database FK is recalled. It can be seen as a dual of the Kowalski’s immediate consequence operator TKB [36]. Definition 2 Let {p1,...,pn}be a set of variables and KBa deductive database on it. The failure operator of KB is the mapping FKB :2n→2nsuch that for I∈2n,FKB(I)is an interpretation FKB(I):{p1,...,pn}→{0,1}where FKB(I)(pk)=1 if for each rule L1∧···∧ Ln→pkin KB,max i∈{1,...,n}I(Li)=1 holds (for k∈{1,...,n}); otherwise, FKB(I)(pk)=0. Let us remark that, according to the definition, if there is no rule in KB with pkin its head, then FKB(I)(pk)=1, for all interpretation I. Kowalski’s operator TKB allows to characterize the models of KB(see, e.g. [18]) in the sense that an interpretation Iis a model of KB if and only if TKB(I)⊆I. Proposition 1 shows that the failure operator FKB also allows to characterize the F-models. The intuition behind the failure operator is to capture the idea of immediate failure in a similar way that the operator TKB captures the idea of immediate consequence. Proposition 1 [39] Let K B be a deductive database. – An interpretation IFis an F-model of K B if and only if IF⊂FKB(I). – The failure operator FKB is monotone, over the set of the interpretations of K B. Since the image of an interpretation by the FKB operator is an interpretation itself, it can be iteratively applied. Definition 3 Let KBbe a deductive database and FKB its failure operator. (a) The mapping FKB ↓: N→2nis defined as follows: FKB ↓0=I↓and FKB ↓n= FKB (FKB ↓(n−1)) if n>0. In the limit, it is also considered FKB ↓ω= k≥0 FKB ↓k (b) The mapping FKB ↑: N→2nis defined as follows: FKB ↑0=I↑and FKB ↑n= FKB (FKB ↑(n−1)) if n>0. In the limit, it is also considered FKB ↑ω= k≥0 FKB ↑k Bearing in mind that the number of rules and variables in a deductive database are finite, the next Proposition is immediate. Proposition 2 Let K B be a deductive database and FKB its failure operator. (a) There exists n ∈Nsuch that FKB ↑n=FKB ↑k for all k ≥n. (b) There exists n ∈Nsuch that FKB ↓n=FKB ↓k for all k ≥n. Let us remark that Proposition 2implies that the number of computation steps for reaching the above limits is finite. Example 2 Let us consider again the database KBused in Example 1and its failure operator. The following interpretations are obtained. FKB ↓0=I↓=(0,0,0,0,0,0,0,0,0) FKB ↓1=FKB(FKB ↓0)=(0,0,0,0,0,0,1,0,0) FKB ↓2=FKB(FKB ↓1)=(0,0,0,0,0,1,1,0,0) FKB ↓3=FKB(FKB ↓2)=(0,0,0,1,0,1,1,0,0) FKB ↓4=FKB(FKB ↓3)=(0,0,0,1,1,1,1,0,0) Since FKB ↓5=FKB ↓4, then FKB ↓ω=(0,0,0,1,1,1,1,0,0) FKB ↑0=I↑=(1,1,1,1,1,1,1,1,1) FKB ↑1=FKB(FKB ↑0)=(0,1,1,1,1,1,1,1,1) FKB ↑2=FKB(FKB ↑1)=(0,0,1,1,1,1,1,1,1) FKB ↑3=FKB(FKB ↑2)=(0,0,0,1,1,1,1,1,1) Since FKB ↑4=FKB ↑3, then FKB ↑ω=(0,0,0,1,1,1,1,1,1) 2.3 Procedural Semantics of Rule-based Deductive Databases The main result of this paper is the characterization of the set of variables obtained by the non-monotonic inference rules CWA and NFF via the procedural behaviour of an SN P system. Let us recall that a rule Ris said non-monotonic if there exist two interpretations I1 and I2with I1⊆I2such that R(I1)R(I2). For the sake of completeness, some basics of the procedural semantics of deductive databases are recalled.5Agoal is a formula ¬B1∨ ··· ∨ ¬Bnwhere Biare atoms. As usual, the goal ¬B1∨···∨¬Bnwill be represented as B1,...,Bn→.Wealsoconsider the empty clause as a goal. Given a goal G≡A1,...,Ak−1,Ak,Ak+1,...,An→and aruleR≡B1,...,Bm→Ak, the goal G≡A1,...,Ak−1,B1,...,Bm,Ak+1,...,An→ is called the resolvent of Rand G.ItisalsosaidthatGis derived from Rand G.LetKB be a deductive database and Ga goal. An SLD-derivation of KB∪{G}consists of a (finite or infinite) sequence G0,G1,...of goals with G0=Gand a sequence of rules R1,R2,... 5A detailed description can be found in [25]. from KBsuch that Gi+1is derived from Ri+1and Gi.ItissaidthatKB∪{G}has a finite failed tree if all the SLD-derivations are finite and none of them has the empty clause as the last goal of the derivation. The failure set of KB is the set of all variables Afor which there exists a finite failed tree for KB∪{A→}. Example 3 Let KBbe the same deductive database from Example 1. Next, some SLD derivations are calculated: KB∪{p3→} KB∪{p9→} KB∪{p6→} Rule used Goals p3→ R3p1,p2→ R2p1→ R1 Rule used Goals p9→ R8p8→ R10 p9→ R8p8→ . . .. . . Rule used Goals p6→ R6p7→ As shown above, the goals p3→and p9→do not have finite failed trees whereas p6→ does. Finally, it is easy to check that the failure set of KBis {p4,p5,p6,p7}. We give now a brief recall of the formal definition of both inference rules. A detailed motivation of such rules is out of the scope of this paper. The first inference rule for deriving such negative information considered in this paper is the CWA [30]: If A is not a logical consequence of K B,then infer ¬A. The second inference rule called NFF [9]: If K B∪{A→} has a finite failed tree, then infer ¬A, or, in other words, if Abelongs to the failure set, then infer ¬A. The next Theorem is an adaptation of the Th.13.6 in [25] and provides a procedural characterization of the variables in the failure set of a deductive database KB. It settles the equality of two sets defined with two different approaches: on the one hand, the set of variables such that all the SLD-derivations fail after a finite number of steps and, on the other hand, the set of variables mapped onto 1 by the interpretation FKB ↓ω, obtained by the iteration of the failure operator. Theorem 1 Let K B be a database on a set of variables {p1,...,pn}and FKB its failure operator. For all k in {1,...,n},p kis in the failure set of K B if and only if FKB ↓ω(pk)=1 By using this theorem, we will prove in the next section that the finite failure set of a database KBcan be characterized by means of SN P systems. The next Theorem relates the CWA with the failure operator. A proof of it is out of the scope of this paper. Details can be found in [25,39]. Theorem 2 Let K B be a database on a set of variables {p1,...,pn}and FKB its failure operator. For all k in {1,...,n},p kis not a logical consequence of K B if and only if FKB ↑ω(pk)=1 3 Logic Negation with SN P Systems In this section, we bridge the neural model of SN P systems with the inference rules CWA and NFF. The main theorems in this paper claim that the result of both inference rules can be computed in a finite number of steps by an appropriate SN P system. The proof of such results is achieved via some lemmas which link the properties of the SN P systems with the semantics of the deductive databases. Theorem 3 Let us consider a set of variables {p1,...,pn}and a deductive database K B on it. Let I be an interpretation on such set of variables. Let FKB be the failure operator of K B. An SN P system can be constructed from K B such that FKB(I)=C3[1,...,n] where C3is the configuration of the SN P system after the third step of computation. Theorem 3claims the equality of two n-dimensional vectors. The first one is the vector which represents the interpretation FKB(I):{p1,...,pn}→{0,1}obtained by means of the application of the operator FKB to the interpretation I. The second one is the vector which represents the number of spikes in the neurons σ1,...,σ nin the corresponding SN P system in the third configuration. The proof is constructive and it builds explicitly the SN P system. Proof Let KB be a deductive database such that {r1,...rk}and {p1,...pn}are the set of rules and the set of variables. Given a variable pi, the number of rules which have piin the head is denoted by hiand given a rule rj, the number of variables in its body is denoted by bj. The SN P system of degree 2n+k+2. ΠKB =(O,σ 1,σ 2,...,σ 2n+k+2,syn)  can be constructed as follows: –O={a}; –σj=(0,{a→λ})for j∈{1,...n} –σn+j=(ij,Rj),j∈{1,...n},where •ij=I(pj)if hj=0 •ij=I(pj)·hjif hj>0 and Rjis the set of hjrules •Rj={a−→ a}if hj=0 •Rj={ahj−→ a}if hj>0 –σ2n+j=(0,Rj),j∈{1,...k},whereRjis one of the following set of rules •Rj=∅if bj=0. •Rj={al→a|l∈{1,...,bj}}if bj>0 For the sake of simplicity, the neurons σ2n+k+1and σ2n+k+2will be denoted by σGand σT, respectively. –σG=(1,{a→a}) –σT=(0,{a→a}) –syn ={(n+i,i)|i∈{1,...,n}} ∪(n+i,2n+j)|i∈{1,...,n},j∈{1,...,k} and piis a variable in the body of rj ∪(2n+j,n+i)|i∈{1,...,n},j∈{1,...,k} and piis the variable in the head of rj ∪{(G,T), (T,G)} ∪(T,n+i)|i∈{1,...,n} and piis a variable such that hi=0 a a→a G a→λ 1 a→λ 2 a→λ 3 a→a T a→a 4 a→a 5 a→a 6 a→a 7 a→a a2→a 8 Fig. 1 Initial configuration of the SN P system from Example 4 The proof will be split into four lemmas. Although the result of the theorem only concerns to the third configuration, the lemmas are proved in general. Before going on with the proof, the building of the SN P system is illustrated with the following toy example. Example 4 Let us consider the set of three variables {p1,p2,p3}, a database on it with two rules r1≡p1→p2r2≡p1,p2→p3 and the interpretation I↓=(0,0,0). According to the notation, in this case n=3, k=2, h1=0, h2=1, h3=1, b1=1andb2=2. The associated SN P system has 2n+k+2=10 neurons and its initial configuration is depicted in Fig. 1. Since the interpretation is I↓,there is only one spike in this first configuration C0. It is placed on the neuron σG.Therulea→a in σGis applied and the unique spike in the configuration C1is placed in σT.SinceσThas two outgoing synapses, the application of the rule a→ain it produces two spikes. Therefore, in the configuration C2there are two spikes in the SN P system: one of them in σGand the other one in σ4. The application of the rule a→ain σGsends one spike to σT,sointhis neuron there is a spike in the configuration C3.Sinceσ4has three outgoing synapses, the application of the rule a→asends one spike to σ1, another to σ7and a third one to σ8. To sum up, in the configuration C3, there are four spikes in the system, each of them in the neurons σT,σ1,σ7and σ8. According to the theorem, in order to know FKB(I↓)it suffices to check the number of spikes in the neurons σ1,σ2and σ3at the configuration C3.Inother words, this SN P system has computed FKB(I↓)=(1,0,0). Next, the following lemmas will be proved. Lemma 1 For all t ≥0,inthe2t-th configuration C2tthe neuron σGhas exactly one spike and σTis empty. Proof The result will be proved by induction. The lemma holds in the initial configuration. The inductive assumption is that in the configuration C2t, the neuron σTdoes not contain spikes and the neuron σGcontains exactly one spike. There is only one incoming synapse in σGwhich comes from σT, and vice versa. Furthermore, the unique rule that occurs in each neuron is a→aso, in C2t+1,σGhas consumed its spike and does not contain any spike, and the neuron σTcontains exactly one spike. For the same reasoning, in C2t+2,σT has consumed its spike and the neuron σGcontains exactly one spike.  10. Díaz-Pernil D, Gutiérrez-Naranjo MA (2018) Semantics of deductive databases with spiking neural P systems. Neurocomputing 272:365–373 11. Floreano D, Mattiussi C (2008) Bio-inspired artificial intelligence: theories, methods, and technologies. MIT Press, Cambridge 12. Gallaire H, Minker J (eds) (1978) Logic and data bases, symposium on logic and data bases, Centre d’études et de recherches de Toulouse, 1977. Advances in data base theory. Plemum Press, New York 13. Gerstner W, Kistler W (2002) Spiking neuron models: single neurons, populations, plasticity. Cambridge University Press, Cambridge 14. Gilpin LH, Bau D, Yuan BZ, Bajwa A, Specter M, Kagal L (2018) Explaining explanations: an approach to evaluating interpretability of machine learning. arXiv:1806.00069 15. Goodfellow I, Bengio Y, Courville A (2016) Deep learning. MIT Press, Cambridge 16. Graciani C, Riscos-Núñez A, P˘aun G, Rozenberg G, Salomaa A (2018) Enjoying natural computing: essays dedicated to Mario de Jesús Pérez-Jiménez on the Occasion of His 70th Birthday. Lecture Notes in Computer Science. Springer International Publishing 17. Hammer B, Hitzler P (eds) (2007) Perspectives of neural-symbolic integration, studies in computational intelligence, vol 77. Springer, Berlin 18. Hitzler P, Seda AK (2011) Mathematical aspects of logic programming semantics. Chapman and Hall/CRC studies in informatics series. CRC Press, Boca Raton 19. Huang K, Zhang G, Wei X, Rong H, He Y, Wang T (2016) Fault classification of power transmission lines using fuzzy reasoning spiking neural P systems. In: Gong M, Pan L, Song T, Zhang G (eds) Bio-inspired computing—theories and applications—11th international conference, BIC-TA 2016, Xi’an, China, October 28–30, 2016, Revised selected papers, Part I, Communications in computer and information science, 681st edn. Springer, Berlin, pp 109–117 20. Ibarra OH, Leporati A, P˘aun A, Woodworth S (2010) Spiking neural P systems. In: P˘aun Gh, Rozenberg G, Salomaa A (eds) The Oxford handbook of membrane computing. Oxford University Press, Oxford, pp 337–362 21. Ionescu M, P˘aun Gh, Yokomori T (2006) Spiking neural P systems. Fundamenta Informaticae 71(2– 3):279–308 22. Jaffar J, Lassez J, Lloyd JW (1983) Completeness of the negation as failure rule. In: Bundy A (ed) Proceedings of the 8th international joint conference on artificial intelligence. Karlsruhe, FRG, August 1983. William Kaufmann, New York, pp 500–506 23. Kakas AC (1992) Default reasoning via negation as failure. In: Lakemeyer G, Nebel B (eds) Foundation of knowledge representation and reasoning, Lecture notes in computer science, vol 810. Springer, Berlin, pp 160–178 24. Lifschitz V (1999) Answer set planning. In: DD Schreye (ed) Logic programming: the 1999 international conference, Las Cruces, New Mexico, USA, November 29–December 4, 1999. MIT Press, Cambridge, pp 23–37 25. Lloyd J (1987) Foundations of logic programming. Symbolic computation: artificial intelligence. Springer, Berlin 26. Maass W (1997) Networks of spiking neurons: the third generation of neural network models. Neural Netw 10(9):1659–1671 27. Montavon G, Lapuschkin S, Binder A, Samek W, Müller K (2017) Explaining nonlinear classification decisions with deep Taylor decomposition. Pattern Recogn 65:211–222 28. Pan L, P˘aun Gh, Zhang G, Neri F (2017) Spiking neural P systems with communication on request. Int J Neural Syst 27(8):1–13 29. Pinkas G (1991) Symmetric neural networks and propositional logic satisfiability. Neural Comput 3(2):282–291 30. Reiter R. On closed world data bases. In: Gallaire and Minker [13], pp 55–76 31. Samek W, Binder A, Montavon G, Lapuschkin S, Müller K (2017) Evaluating the visualization of what a deep neural network has learned. IEEE Trans Neural Netw Learn Syst 28(11):2660–2673 32. Sinapayen L, Masumori A, Ikegami T (2019) Reactive, proactive, and inductive agents: an evolutionary path for biological and artificial spiking networks. arXiv:1902.06410 33. Song T, Pan L (2016) Spiking neural P systems with request rules. Neurocomputing 193:193–200 34. Song T, Zou Q, Liu X, Zeng X (2015) Asynchronous spiking neural P systems with rules on synapses. Neurocomputing 151:1439–1445 35. Tran SN, d’Avila Garcez AS (2018) Deep logic networks: inserting and extracting knowledge from deep belief networks. IEEE Trans Neural Netw Learn Syst 29(2):246–258 36. van Emden MH, Kowalski RA (1976) The semantics of predicate logic as a programming language. J ACM 23(4):733–742 37. Wang T, Zhang G, Zhao J, He Z, Wang J, Pérez-Jiménez MJ (2015) Fault diagnosis of electric power systems based on fuzzy reasoning spiking neural P systems. IEEE Trans Power Syst 30(3):1182–1194 38. Wu T, Zhang Z, P˘aun Gh, Pan L (2016) Cell-like spiking neural P systems. Theor Comput Sci 623:180–189 39. Yang F (1991) Duality in logic programming. Tech. Rep. Paper 119, Electrical Engineering and Computer Science Technical Reports. Syracuse University 40. Zeng X, Zhang X, Song T, Pan L (2014) Spiking neural P systems with thresholds. Neural Comput 26(7):1340–1361 41. Zhang G, Pérez-Jiménez M, Gheorghe M (2017) Real-life Applications with MembraneReal-life applications with membrane computing. Emergence, complexity and computation. Springer, Berlin