Logic Programming - Science topic

Sequent Calculus might work for you.

I think ASP can be useful for solve temporal logic programs.

a problem domain can be modeled as ASP rules and temporal logic constraints can be represented as ASP constraints.

then a set of answer sets can be generated where each answer set corresponds to a model of the system. thanks to the  temporal logic constraints, The result will be a set of  answer sets ( i.e. stable models )  where a temporal logic property holds . I have used ASP for a model checking problem in the attached paper. I hope you want it useful.

Hi Mai,

Very briefly, logic programming is a programming language paradigm which typically expresses properties of inputs and outputs using first-order clausal logics often with extra notations to control evaluation. Each clause specifies that if a finite number of conditions are satisfied then a conclusion is satisfied. Please see examples in the Wikipedia article and well-known texts such as W.F. Clocksin and C.S. Mellish, "Programming in Prolog", Third ed., Springer Verlag, 1987.

Generally, the method of evaluating programs is under-specified and these languages have been described as "declarative" for this reason, e.g. a program to sort lists often can just be read as a specification of a sorted list. This should be compared to imperative languages where each step of a sorting algorithm is encoded explicitly.

In these languages,  unifiability of first-order predicates is used during evaluation. In constraint logic programming, constraints are added to clauses and need to be solvable too.

Regards,

David Wolfram

Peter gave very good pointers.

If you need that kind of logic in other high-level programming language like C++, try googling for a library implementing it first.  If you don't find anything, you would need to write your own user defined class based on your chosen logic axioms (or specifications like IEEE). Should you go this way, I strongly suggest that you do it in a Test Driven manner (a la TDD) to cover all cases with tests.

Yes, they have...

Pierre, I agree that nonmon reasoning can be confusing, but not only for naive users.  Experts never take any kind of reasoning at face value.  They always ask follow-on questions:  What were the assumptions?  Where did the data come from?  How did you derive that answer from those assumptions and that data?

One advantage of FOL theorem provers is the ability to generate an explanation:  Show every step of the proof -- every axiom or data point and every inference.  With controlled NLs, each step can be translated to the same CNL that the user knows.

For nonomon reasoning, belief revision has the same advantage as FOL.  Each revision step can be translated to the CNL.  The final proof is a purely classical FOL proof that can be explained by the above method.

For complex proofs, the amount of detail can be overwhelming, but the expert needs that kind of detail.  Intelligent users who don't have much knowledge of FOL can learn FOL by studying the explanations.  Anyone who is both naive and lazy will always be confused.

John

Your answer seems to second my statements, namely first that to solve a natural language puzzle you often need – beyond what is explicitly stated in the puzzle – contextual knowledge usually derived from the human sphere, and second that each puzzle requires its own specific contextual knowledge which prevents finding general solutions.

But you are also addressing a second issue, namely the relation between natural language and logic. Having developed Attempto Controlled English – a subset of English that can be translated into logic – I completely agree with you that formal languages are not capable of representing the fullness of natural language. However – again based on my experience with controlled languages – there are cases where natural language texts can be adequately translated into logic and then usefully submitted to logic deduction. Besides the already discussed logical puzzles, examples are technical texts like software specifications, simulations, rule-based systems like clinical practice guidelines, regulations, and ontologies. In each of these cases controlled languages translatable into logic help users who need formal reasoning but are not familiar with formal notations.

I concur with your statement "The boundary between what is part of logic and what belongs to semantics is neither fixed nor clear." In the case of Attempto Controlled English we took this boundary into account by leaving the meaning of the so-called content words (nouns, verbs, adjectives, adverbs) open to the interpretation by the human users.

Resolution, thus unit resolution, is sound. So the "only if" part is immediate.

At the ground level, the "if" part is really easy, but the trick at the first order level is showing that "factoring" is not needed. JACM 21,4 is overkill, but it does this amongst other results.

Intuitively, a ground positive unit proof can be lifted to (a proof of) the first order clauses, of which it is a set of instances, in the usual way -- EXCEPT that a single ground step may correspond to a unit resolution involving a clause in which k literals have been factored together into one. But unification theory allows this one step on a factor  to be replaced by k (unit) steps on the original clause, resulting in the same resolvent produced by the one step with the factor.

(This is mostly intuition and not even a proof sketch.)

The QPL on Quantiki is a complete nonsense !

This language allows one to dump the "internal state which is diffrent from measurement, since it does not influence the state of the quantum machine and can be realised only using simulator". Note that internal state has no coeficients in any base unles measurement is actually performed (in that base), and then, of course the calculation would be destroyed. Mere existenmce of such states in the computer means terrible reduction of wealth of combinations that quantum computer takes aall into account simultaneously - therefore the calculation is not quantum, and then, of course, the simulaiton will fail at least for some calculations.

The bottom line is that QPL is a language used for programming a Turing machine which then runs some "simulation" in a completely deterministic fashion. If this would succeed we would not need quantum computers, would we ?