VSL 2014: VIENNA SUMMER OF LOGIC 2014

GLOBAL KEYWORD INDEX

All VolumesAll PapersGlobal Author IndexGlobal Keyword Index
Shortcuts: (2ABCDEFGHIJKLMNOPQRSTUVWXZ
(
(co)datatypes
(co)induction
(co)recursion
(student submission)
(weak) orthogonality
2
2-valued semantics for logic programs
A
Abduction
Abductive logic programming
Abductive Reasoning
abnormal behavior detection
ABox
Absorption
abstract argumentation
abstract argumentation semantics
abstract datatypes
abstract diagnosis
abstract domain
abstract domain combinator
abstract DPLL
abstract interpretation
Abstract machine
Abstract Machines
abstraction
Abstraction refinement
abstraction-refinement
ACC
access control
accessibility conditions
accidental
Accountability
Accountable escrow
Accountable-escrowed encryption
accumulation
ACL2
ACL2(r)
ACT-R
action
action and change
Action histories
action languages
Actor Prolog
Acyclic queries
acyclicity properties
admissible rule
admissible rules
Admissible strategies
adversary models
Aeronautics
affine arithmetic
Affine logic
Agda
Agent Architectures
agent programming
Aggregates
aggregation
aggregators in probabilistic models
ai
ALC
ALCH
ALCQIO
Algebra of maps
algebraic data types
Algebraic effect
Algebraic effects
algebraic effects and handlers
Algebraic Message Model
Algebraic specification
Algebraic structure
algebraic unification
algorithm
Algorithm Configuration
Algorithm Schedules
Algorithm Selection
Algorithm Visualization
Algorithmic randomness
algorithms
Algorithms Portfolio
aliasing
Allen algebra
alliances in graphs
alternating pushdown systems
alternating temporal logic
alternating Turing machine
amortised resource analysis
amortized complexity
analyticity
Ancestral logic
Android
Android permissions
angry birds
annotations
anomalous human activity
Anonymity Guarantees
Anonymous Communication Protocols
answer extraction
answer set programming
answer set programming (ASP)
answer set programming extensions
Answer Set Solving
answer-set programming
anytime algorithms
app
app functionality
application
applications
Applications of logic to combinatorics
applicative bisimulation
applied KR for design computing
Approximate inference
Approximate Reachability
approximation
Approximation Fixpoint Theory
Approximation theorem
Approximations
Apéry constant
arctangent
Argument
argumentation
argumentation framework
Argumentation frameworks
argumentation semantics
Array programs
Arrays
artifact-centric systems
Artificial Intelligence
ASP debugging
Assertions
assumptions
assurance
assurance case
Assurance cases
Asymmetric unification
asynchronous systems
Asyncrhonous Interaction
ATL
ATL and ATL*
ATL+
Atomic Decomposition
Atomic flows
Atomicity
ATP
ATP Competitions
ATP process
Attack trees
Attractor
attribute transition
attribute-based encryption
auction strategy
auction theory
Audit
authentication
Automata
automata theory
Automata-Based Reasoning
automate reasoning
automated deduction
Automated design
automated reasoning
automated theorem prover
automated theorem proving
automated verification
automatic program calculation
automatic sequences
automatic theorem provers
Automatic verification
automation
Automation of Mathematics
automatizability
Autonomous systems
autonomy oriented computing
auxiliary relations
AVATAR
awareness
axiomatic semantics
axiomatization
Ayciclicity conditions
B
backdoor sets
background theories
Backtracking
Backtracking Search
backward proof search
Bar recursion
Batch verification
Bayesian inference
Bayesian model selection
Bayesian networks
BDD
Beagle
Beam Splitter
Behavioral Synthesis
Behavioural Differential Equations
belief base
Belief bias
belief change
belief merging
belief probability
belief revision
benchmark
benchmarking
benign
Bernstein basis
Betweenness centrality
BHK interpretation
Bi-Abduction
bi-intuitionistic logic
biaffine PROP
Bidirectional
Big Data
Bilinear Pairing
bimodule
binary decision diagrams
biocompilaton
Bioengineering
Biological Networks
Biological Systems
biology
BioPortal
bisimulation
bisimulation invariance
bisimulation up-to
Bit-vector
Bit-vector Preprocessing
bit-vectors
block-ciphers
Blocked Clause Decomposition
Blocked Sets
Blum-Shub-Smale
bmc
Boehm tree
Boolean Algebra and Presburger Arithmetic
Boolean circuit complexity
Boolean Games
Boolean optimization
boosting completeness
Bootstrapping
Borel determinancy
Borel measurable payoffs
bottom-up evaluation
Bound Analysis
bounded arithmetic
bounded model checking
Bounded Polymorphism
bounded quantifier alternation
bounded treewidth
Boundedness problem
Bounds-propagation
Branching Time
branching VASS
Brownian motion
Brzozowski derivatives
Buchholz rule
Buchi automata
bulk synchronous parallelism
Business Process Management
Büchi automata
C
CafeOBJ
Calculus of Inductive Constructions
Calculus of structures
Call by name
Call by value
call-by-name
call-by-name and call-by-value
call-by-need lambda calculus
call-by-value
Canonical Structures
capabilities
cardinal number
cardinality constraints
case studies
Categorical semantics
category theory
causal graph
Causality
causation
cautious reasoning
CCS
CDCL
CDCL algorithm
CDCL solvers
cdf interval
CEGAR
Central Limit Theorem
CERES
certain answers
certain knowledge
Certificates
certification
Certifying Algorithms
Certifying transformation
chaining predictors
challenging
channel capacity
characterisation theorem
chemical master equation
Chemical Reaction Network
Chemical reaction networks
Chinese Remainder Theorem
Church's type theory
Church-Rosser
circular proofs
Circumscription
claim
classical first-order logic
classical first-order logic with inductive predicates
classical linear logic
classical logic
Classical Modal Logics
Classical Planning
classical realizability
Classification
clausal proofs
Clause Learning
clause sharing
clinical decision support
Clique-Width
clitic pronouns
Closed Sets
Cloud Computing
CLP applications
Clustering
CNF formulas
CNF partitioning
coalgebra
coalgebras
codata
codatatypes
code generation
code verification
Coercion
cognitive robotics
Cognitive Science
coherence
coherent implications
Coherent Light
coherent theory
coinduction
coinductive predicates
Coinductive Types
Collaboration
Combination
Combination method
combination of equational theories
Combination problem
Combinatorial hypermap library
Combinatorial optimization
combinatorial proof
Combinatorial proofs
combinatorial topology
combinatorics
Combined Approach
combined complexity
communicating automata
Community detection
Community Structure
commutative context-free grammars
Compact Closed Categories
Comparative evaluations
Comparative user evaluation
comparatives
compartmental models
competency question
Compilation
Compiler certification
compiler construction
compiler intermediate representation
compiler verification
complete partial orders
completeness
completeness of first-order logic
Completeness theorem for classical logic
completeness theorems
completion
complex events
complex events recognition
Complex Networks
complexity
complexity analysis
complexity hierarchies
complexity of evaluation
complexity of query answering
complexity of rewriting
complexity theory
Composition Synthesis
compositionality
comprehension model
compression
computability
Computability and complexity
Computation of least general generalizations for nominal terms
computational cognitive modeling
Computational Complexity
computational content
computational indistinguishability
computational linguistics
computational logic
computational model of narrative
Computational Models
computational neuroscience
Computational Pragmatics
computational psychology
computational reflection
computational semantics
computational social choice
computational soundness
computer algebra
computer music
computer vision
computer-aided architecture design
Computer-Aided Cryptography
computer-supported collaborative work
Concept Learning
Concept matching
Concept Similarity
Conceptual Similarity
Concolic
Concolic Testing
concrete domains
concurrency
concurrency and synchronization
Concurrency Testing
concurrent constraint paradigm
Concurrent Constraint Programming
Concurrent Data Structures
Concurrent datatypes
concurrent logic programming
Concurrent Programming
Concurrent programs
Concurrent systems
Condensed-matter physics
condition elimination
conditional logics
Conditional Queries
conditional rewriting
conditional term rewriting
conditional term rewriting system
conference management system
confidentiality
conflict resolution
confluence
confluence in algebra
conformant planning
ConGolog
congruence
Congruence Closure
conjunctive queries
Conjunctive query answering
conjunctive query evaluation
Connectedness
connection calculus
connection matrices
Consequence-based Calculus
consequence-based reasoning
Consequences
conservative extension
Conservative extensions to stable model semantics
consistency
Consistency Checking
Constant Definition
constrained clauses
constrained ordered resolution
Constraint ASP
Constraint Handling Rules
Constraint Horn Clause
constraint logic
Constraint Logic Program
Constraint Logic Programming
Constraint Postponement
Constraint Programming
Constraint Propagation
constraint reasoning
constraint satisfaction
constraint satisfaction problem
Constraint satisfaction problems
constraint solver
constraint solving
Constraint-based synthesis
Constraints
Constructive algebra
constructive mathematics
constructive negation
Constructive temporal logic
Constructive type theory
constructors
Content representation
context semantics
context-based reasoning
context-free grammars
context-sensitive rewriting
Contexts
contextual equivalence
Contextual Reasoning
contextualized description logics
contingent planning
continuation
continuation passing Prolog
continuation semantics
continuations
continuous noise in effectors and sensors
continuous payoffs
Continuous Time
continuous time Markov chains
contraction
contracts
Control
Controllability
controller synthesis
Conversion
conversion algorithm
conversion equivalence
Conversions
convex hull
convex optimisation
convex structures
copattern matching
Coq
Coq proof assistant
Coq/SSReflect Proof Assistant
Corecursion
cores
correct program transformation
correctness
correctness criterion
cost automata
Cost Models
cost monadic second-order logic
countable choice
countermeasures
counting
counting quantifiers
Courcelle's theorem
coverability problem
coverage metrics
CP-logic
CP-nets
CPO
cps translation
Craig interpolation
Craig's interpolation
crawling
creative telescoping
Criterion~H
critical pair
critical pairs
critical peak
critically trivial
crowd sourcing
cryptographic definitions
Cryptographic protocol analysis
cryptographic protocols
CSP
CTL
cumulative quantification
Cumulativity
cut elimination
cut-elimination
cut-introduction
Cutting and Packing
cyber-insurance
cyber-physical security protocols
Cyber-Physical Systems
Cycle rewriting
cyclic and structural induction
cyclic lambda-terms
D
Dalvik
Danos-Regnier criterion
data complexity
data mining ontology
Data structures
data structures for tableaux calculi
data synchronization
data trees
data visualization
Data-aware dynamic systems
database
Database generation
database querying
Database semantics
Database theory
Databases
Datalog
Datalog rewritability
datalog rewriting
Datapath Abstraction
Datatypes
De Bruijn
deadlock
Debugging
decidability
decidability and complexity
Decidability results
Decision
decision diagrams
decision method
decision procedure
decision procedures
Decision Rules
Decision trees
Declarative modeling
declarative programming language constructs
declarative specification
Declarative systems
declassification
decomposition theorems
Decreasing Diagrams
deduction
deduction modulo
deductive databases
deductive program verification
deductive verification
Deep inference
Default logic
default negation
defeasible inheritance
defeasible knowledge
Defeasible reasoning
Defectivity
Definability
Definition evaluation
Definition refining
definitional package
degree
degree sequences
degrees of belief
delay
delegatable anonymous credentials
delimited control operators
Delineation semantics
denotational semantics
density elimination
Deontic logic
dependence
dependencies
Dependency graphs
dependency pair framework
dependency parsers
Dependency Schemes
dependent elimination
Dependent types
dependently typed lambda calculus
derivability
Derivational complexity
Description logic
Description Logic Ontologies
Description Logics
Description Logics and Ontologies
Descriptive complexity theory
Design
deterministic transitive closure
determinization
Device Drivers
diagnosis
diagnosis discrimination
Dialectica translation
dialog systems
dialogue
Dialogue Modeling
dict
Difference Equations
Differential Evolution
Differential Linear Logic
differential power analysis
Differential Privacy
Differential Temporal Dynamic Logic
Diffie-Hellman
Diffie-Hellman key exchange
Diffnets
digital forensics
dilation
Direct style
Directed Testing
discourse analysis
Discrete dynamical systems
discrimination tree
disjoint unions
disjunctive answer set programming
Disjunctive Datalog
Disjunctive existential rules
dispensability
display calculi
distance metrics
Distributed Algorithm
distributed computing
Distributed Constraint Optimization Problems
distributed programming
distributed search
distributed version control systems
Distribution Semantics
Distributional Semantics
Diversification
divide-and-conquer
DL Lite
DL reasoning
DL-Lite
DL-programs
DL-safe rules
DNA computing
DNA nanotechnology
DNA Strand Displacement
DNF duality
DNF minimization
Documentation
Domain Independence
domain specific modeling
domain theory
Domain-specific languages
Domains
Dominance
Double negation translation
Doxastic Logic
DPLL
DPLL(T)
DQBF solving
DRed
DRUP
duality
Dynamic Algebra
Dynamic Analysis
dynamic consistency checking
Dynamic Domains
Dynamic information flow control
dynamic logic
dynamic logics
dynamic pattern calculus
Dynamic Predicate Logic
dynamic programming
dynamic quantification
dynamic security enforcement mechanisms
Dynamic systems
dynamic techniques
E
E-matching
Eager Languages
Earley deduction
economics
economics of security
education
effect system
Efficient protocols
EFL-ontology
egalitarianism
Ehrenfeucht-Fraïssé games
EL
EL TBoxes
elementary algorithms
elementary interpretations
Elliptic Curves
embedded systems
embedding
Empire
empirical analysis
Empirical investigation
Emptiness
Emptiness Check for Generalized Buchi Automata
encoding
endocytosis
energy games
Engineering
Entropy of formal languages
enumeration
enumerators
epidemic models
epistemic logic
epistemic logic programs
epistemic planning
Epistemic Specification
epistemic specifications
epistemic temporal specification
Epsilon
equality
Equality constraints
equational constraint
equational logic
equational simplification
Equational Unification
equilibrium logic
Equilibrium Semantics
equivalence
equivalence properties
equivalence relation
Error localization
Error-tolerant reasoning
Escrowed public key
ESL Design
esoteric language
evaluation
Event structures
Event-B
events API
evidence
exact algebra
Exact Inference
Exact Learning
exact real-number computation
Excessiveness
Executable Formal Models
execution
execution monitoring
Execution monitors
Existence
existential rules
Experiment
experiment design
Experimental evaluation
Experimental mathematics
Experimentations
Explanations
Explicit Substitutions
explosion rule
exponential time algorithm
expressive completeness
Expressive Description Logics
Expressive Ontologies
expressive power
expressive TBoxes
expressiveness
extended resolution
extensional model
extensional models
extensionality axiom
Extraction
F
Faceted search
FaCT++
failed literal detection
Fair CTL
Fair Termination
fairness
fast-growing complexity
Fault Localization
fault-tolerant computing
feasibility checks
feature extraction
feeble orthogonality
Feferman-Vaught
fibrations
Fiduccia-Mattheyses algorithm
filter-model
Finitary matching
Finite and Infinite Transition Systems
finite automata
Finite Domain Solver
Finite Lattices
Finite model property
finite model theory
finite satisfiability
Finite satisfiability and implication algorithm
Finite-valued Logic
Finiteness
Firewall
First order
first order logic
first order logic with majority quantifiers
first-order
First-order classical proof nets
First-order Classical Sequent Calculus
first-order logic
First-Order Logic Model Checking
first-order logic of discrete linear order
first-order modal logic
first-order model checking
First-order temporal logic
first-order term rewriting
first-order theorem proving
Fisher information matrix
fix-sized subontologies
fixed parameter tractable
Fixed point theory
fixed-parameter complexity
Fixed-Parameter Tractability
Fixpoints
FL_0
Flattening
floating point
Floating-label systems
Floating-Point Arithmetic
Flow-sensitive references
Floyd-Hoare logic
flux balance analysis
FO(.)
focalisation
Focus Groups
focused derivations
Focusing
focusing proofs
fodot
Forgetting
Forgetting in Reasoning about Actions
Forgetting in the Situation Calculus
Forgetting/projection/uniform interpolation
formal fuzzy logic
formal mathematics
formal methods
Formal Semantics
Formal Specification
Formal Verification
formal verification of OS
formalisms
formalization
Formalization of mathematics
formalized mathematics
ForMaRE
Formats
Forms of agitation
formula trimming
formulae-as-types
formulas with two occurrences
Fractal Dimension
framework
Frege proofs
Frege systems
full abstraction
Full trees
fun
Function combinators
function introduction
functional dependencies
Functional instantiation
functional notation
functional programming
Functional reactive programming
functional roles
Fuzzy Description Logic
Fuzzy Description Logics
fuzzy logic
Fuzzy Ontologies
fuzzy plurivaluationism
G
gain function
Gale-Stewart games
game characterisations
game semantics
Game theory
games
games on graphs
gamification
gene expression
gene regulatory network
General Models
General resolution
General safe recursion
general stable models
general theory of stable models
generalised entropy measurements
Generalization of nominal terms-in-context
Generalized Craig interpolation
Generalized databases
Generalized Hypertree Decomposition
Generalized Quantifiers
generic
Genetic algorithms
genetic gates
Gentzen
Gentzen's sharpened Hauptsatz
geometric
geometric implications
geometric logic
geometric theory
geometry
Geometry of Interaction
ghost code
git
global assumptions
global caching
Global Constraints
global sensitivity analysis
goal-directed
Goedel T-norm
Golog
GPGPU programming
GPGPUs
GPU
GPUs
Graded theories
grammars
graph algorithms
graph decomposition
graph property
graph rewriting
Graph structured data
graph theory
graphical specification patterns
Graphical user interface
graphics processing units
Graphs
Ground Tree Rewrite Systems
Grounded Equilibrium Semantics
Grounding
Grounding bottleneck
GSOS
Guarded fragment
guarded logics
guarded recursion
Guardedness
Guards
Guillotine Constraint
Gödel Semantics
Gödel t-norm
Gödel's incompleteness theorem
H
Hanf-locality
hard constraint
hard SAT instances
hard subsets
hardness
hardness results
hardware
hardware verification
Hash Tries
hashing
Haskell
heap structures
Henkin's proof
Herbrand functions
Herbrand model
Herbrand Sequent
Herbrand theorem
Herbrand's theorem
HermiT
Heuristics
hierarchical planning
Hierarchized linked implementation
high assurance
High Level Synthesis
High School Timetabling
high-performance computing
higher-dimensional rewriting
higher-order
Higher-order description logics
higher-order logic
higher-order logic programming
higher-order model checking
higher-order model-checking
higher-order pi-calculus
Higher-order programs
higher-order recursion schemes
higher-order rewrite systems
higher-order term graphs
higher-order term rewriting
higher-order unification
Hilbert axiomatisation
Hilbert axiomatizations
Hilbert Axioms
Hilbert systems
Hoare assertions
Hoare logic
HOL
HOL Light
HOL4
Homological algebra
homomorphism preservation in the finite
homomorphisms
homotopy
homotopy type theory
horn
Horn logic
Horn theories
HPC
Human Behavior
Human Factors
Human Reasoning
Human-computer interaction
hybrid algorithm
hybrid automata
hybrid spatial-nonspatial simulations
hybrid stochastic simulations
hybrid stochastic-deterministic simulations
hybrid system models
hybrid systems
Hyper-Ackermannian complexity
hypergraph
Hypergraph decomposition
hypergraph duality
hypergraph partitioning
Hypergraph transversals
Hypergraphs
Hypersequent Calculi
Hypersequents
Hyprgraphs
I
ic3
IC3/PDR
identification constraints
Identification of proofs
Identity
idp
IDP3
Immunization strategy
Imperative Program
imperfect information
Implementation
Implementation and Optimisation Techniques
Implementation Techniques
implicant minimization
implication fragments of substructural logics
Implicature
Implicit Complexity
implicit computational complexity
Implicit Definition
implicit generalization
important separators
improvements in theorem prover technology
incomplete databases
incomplete information
inconsistency handling
inconsistency in probabilistic knowledge bases
inconsistency measures
inconsistency-tolerant query answering
incremental evaluation
Incremental Preprocessing
Incremental reasoning
Incremental SAT
incremental tabling
incremental verification
indexing
IndiGolog
indiscernibility
Individual concepts
Induction
induction reasoning
induction rule
inductive definitions
inductive invariant
inductive predicates
inductive synthesis
Industrial automation
inferences
Infiniband
Infinitary Formulas
infinitary lambda-calculus
infinitary rewriting
Infinitary Trees
Infinite connected graph of bounded degree
Infinite execution
Infinite graph rewriting
Infinite tree
infinite-valued logics
infix probability
Informal semantics
information flow
information flow control
Information Flow Security
Information Hiding
Information preservation
information retrieval
information-flow security
Inhabitation
initial algebra
Input Vectors
Input/output logic
insertion modeling
Insider Threat
Insider Threats
Inspection Points
instability
Instance features
Instance Queries
instance-based theorem proving
instantiation
institutions
Instrospection
integer programming
Integrating CDCL and MP
Integration
integrity of OS
intelligent visual surveillance
Intensional transitive verbs
Intensionalization
Intention and Belief
Interaction
Interaction nets
interactive systems
Interactive Theorem Provers
interactive theorem proving
Interference Scenarios
intermediate verification language
internalization of type classes
interpolants
Interpolation
intersection
Intersection and Union Types
intersection type
intersection types
Interval analysis
interval arithmetic
Interval solvers
intervals
introspection
introspective reasoning
Intuitionism
intuitionistic
intuitionistic hybrid logic
Intuitionistic logic
intuitionistic modal logic
intuitionistic propositional logic
intuitionistic set theory
invariance proofs
invariant computation
invariant synthesis
Invariants
inverse properties
inverse rewriting
inverse roles
IPC API
irrationality proof
Irregularity
Isabelle
Isabelle proof assistant
Isabelle/HOL
Isabelle/PIDE and Isabelle/jEdit
isar
Ising Model
iteration
iterative process
J
Janin-Walukiewicz theorem
Java
Java Virtual Machine (JVM)
jEdit
Jeffrey's rule of conditioning
JSON Schema
Judgment Aggregation
Just-in-time Compilation
justification
justification logic
Justifications
justified belief
K
k-fold Tseitin formula
k-liveness
k-SAT
Kachinuki ordering
Key Compromise Impersonation
KLEE
Kleene algebra
Kleene algebra with tests
Knowledge
Knowledge Acquisition and Forgetting
knowledge base
knowledge base revision
knowledge base system
knowledge compilation
knowledge obfuscation
knowledge representation
Knowledge Representation and Reasoning
Knuth-Bendix completion
KR 2014 paper
kripke model
Kripke semantics
Krohn-Rhodes Theory
Kruskal-Katona Theorem
L
labelled Markov Chains
labelled sequent calculus
labellings enumeration algorithm
Lagrange duality
lambda calculus
Lambda encodings
lambda expressions
lambda mu
lambda-calculus
lambda-mu calculus
Lambek grammars
Language Design
Language Interoperability
language of mathematics
Language Translator
Languages
Large Neighbourhood Search
Large Theories
large-scale ontologies
large-theory automated reasoning
Lasserre
Latin square
Lawvere theories
Lazy Annotation
lazy data structures
Lazy Languages
lazy lists
learning
Learning preferences
leftmost outermost
length
Lexicographic Ranking Function
Lifted inference
Lifting
light logics
limitative results
limited nondeterminism
Lindon interpolation
linear
Linear Algebra
linear arithmetic
linear constraints
linear differential systems
Linear lasso program
linear logic
linear logic programming
linear pi-calculus
linear real problems
linear rewriting and generalized gröbner basis
Linear Temporal Logic
linear time complexity
linear transformation
Linear Types
linear-time temporal logic
Linearity
Linearizability
link formulas
Linked Data
LIO
Liquid types
list homomorphisms
Lists
livelock
Liveness
LLVM
local consistency
local optimum
Local Search
local temporal logic
local theories
local theory extensions
local typedef
local-first
locality
locally finite variety
lock-free data structures
Lock-Freedom
Logarithmic Space
logic
logic of common knowledge
logic of here-and-there
logic of infinite sequences
Logic of Scientific Discovery
Logic over graphs
Logic Progarms
logic program updates
Logic Programming
Logic solvers
logic variables
logic-based modeling
Logical abduction
logical analysis of algorithms
Logical annotations
Logical aspects of computational complexity
logical difference
Logical Errors
logical semantics
Logics
Logics for AI
logics for graphs
logistic regression
Long-distance resolution
loop
Loop Analysis
Loop Detection
loop invariant
loop invariants
Loop Pipelining Transformation
Los-Tarski
low-level code
low-level programming languages
lower bound
lower bounds
LP design and implementation
LTL
LTL Model Checking
LTL Separation
Ludics
Lukasiewicz logic
Lyapunov exponents
M
machine learning
Machine-Learning
Magic Sets
main-memory RDF store
make-easy" teaching approach
malleable signatures
Many core
Manycore
Mapping Analysis
mapping probabilistic logic languages
Mapping Visualization
MapReduce
MapReduce Framework
Maps of graphs
marked regular expressions
Markov Chain
Markov Chain Monte Carlo Techniques
Markov chains
Markov's normal algorithms
Martin Lof randomness
Martin Lof test
Mass Parallelization
Matching
matching logic
Matchmaking
Materialisation
Materialization
mathematical components
Mathematical Morphology
matrix multiplication
max-2-sat
Max-SMT
maximal completion
maximal contraction
Maximal Falsifiability
Maximal interpolants
Maximal Satisfiable Subsets
maximum entropy model
Maximum Falsifiability
Maximum Independent Set
Maximum satisfiability
Maximum satisfiability modulo theories
MaxSAT
MCMC
MDP
mean payoff
mean-payoff and discounted sum
mean-payoff games
Measure
mechanism design
Mechanization of Mathematics
mechanized proof
MELL
memory fence synthesis
memory safety
mereology
Message Formats
Message Passing
message passing systems
message sequence charts
Meta
meta modelling
meta programming
meta-heuristic search
metabolic regulation
metadata
micro-kernel OS
Midsequent theorem
MILS (multiple independent levels of security)
Min-closed constraints
MinAs
minimal change
Minimal Correction Subsets
Minimal hitting set dualization
Minimal model generation
minimal model semantics
Minimal modules
minimal network
minimal unsatisfiable core
Minimal Unsatisfiable Subsets
Minimum Satisfiability
Minisat
Minkowski sum
Minlog
missing information
Mixin
mixin inheritance
MLL
MMT
mobile computing
mobile devices
Modal and temporal logics
modal logic
Modal Logics
Modal Logics of Confluence
modal mu-calculus
modal tableaux
Modal Temporal Logics
modal µ-calculus
Mode checking
model
model analysis
model checking
model composition
Model construction
model counting
Model Finding
Model generation
model revision
Model Synthesis
model theory of incompleteness
model-based reasoning
Model-Based System Development
model-based theorem proving
Model-checking
model-finding
Modeling
Modelling
modelling and analysis of qualitative behaviour of biological systems
models
models of incompleteness
modes of operation
modular reasoning
Modular Solver
modular systems
modular verification
modulare SMT solving
Modularisation
Modularity
modularization
Module systems
modules
modulo counting quantifiers
Molecular computing
Molecular programming
Monad
Monadic
monadic ASP
monadic language
Monadic metalanguages
monadic program schemes
monadic recursion schemes
monadic second-order logic
Monads
Monads with arities
monitor
monitoring
Monoid
monomorphization
Monotone induction and coinduction
Monotone proofs
Montague semantics
Monte-Carlo Tree Search
morphic words
MSO
MSO-automata
mu-calculus
Muller games
multi agent
Multi Context Systems
Multi-agent systems
Multi-Attribute Decision Making
multi-context systems
Multi-counter automata
Multi-Criteria Decision Making
Multi-Paradigm Programming
Multi-Stack Pushdown Systems
multi-type sequent calculi
Multi-valued logic
Multi-valued Logic Programming
multiagent dynamic systems
Multicore
multidimensional quantitative games
multiplicative linear logic
multiprocessor
multiscale simulations
multiset comprehension
Multiset Rewriting
Music
Mutability
mutable state
mutual exclusion protocol
N
n-interpolation
Narrative
Nash bargaining
Nash equilibria
Nash equilibrium
natural deduction
natural language
natural language processing
natural logic
near semi-rings
Need for Cognition
Needed step
negation as failure
negation-as-failure
Negative translation
neighborhood embedding
Neighborhood Semantics
nested Petri nets
nested sequent calculi
nested sequents
Nested Words
network protocol
network protocols
network rewriting
Network security
networks
neurobiology
new features
Noetherian induction
nominal
Nominal Anti-Unification
nominal automata
Nominal Equivariance Algorithm
nominal schemas
Nominals
Non monotonic reasoning
Non-circular Justifications
non-classical logics
non-determinism
non-deterministic semantics
Non-disjoint union of theories
non-interference
Non-Linear
non-linear real arithmetic
non-monotonic fixed point theory
Non-monotonic Logic Programming
non-monotonic logics
Non-monotonic reasoning
Non-orthogonality
non-standard analysis
Non-standard inferences
non-standard reasoning
non-termination
Non-uniform inductive types
nonconvex subexpression
nondeterminism
noninterference
Noninterleaving semantics
nonlinear real arithmetic
Nonmonotonic Reasoning
Nontermination
normal form
normal forms
Normal modal logic
normal modal logics
Normalisation
Normalisation paths
normalization
normalization equivalence
Normative reasoning
NP-completeness
Number Restrictions
Numerical Accuracy
Numerical representations
Nuprl
O
OBDA
OBDA design tools
OBDD
Object Oriented Design
object-oriented logic programming
Object-Oriented Programming
Observational Equivalence
Observational Semantics
Observational Type Theory
OCaml
Omega-automata
online banking
Ontologies
ontology
Ontology Based Data Access
ontology based query answering
Ontology Change
Ontology Decomposition
ontology engineering
ontology languages
Ontology modularisation
ontology modularity
Ontology Reasoning
Ontology Repair
Ontology-based data access
Opaqueness
open street map
open-endedness
Open-Source
open/closed world semantics
OpenCL
operational semantics
Optimal Networks
optimisation
optimization
optimizing compilers
Orbits for functions in finite domains
Ordered Disjunction
Orderings
ordinal number
Ordinals
orthogonalisation
Orthogonality
OS FSM model
Otter
OWL
OWL 2 EL
OWL 2 profiles
OWL 2 QL
OWL 2 reasoners
OWL 2 RL
OWL Reasoner
OWLlink
P
p-simulation
padlock
paraconsistent logics
parallel
Parallel Closedness Theorem
parallel computing
parallel deduction
Parallel Local Search
parallel materialisation
parallel portfolio solver
parallel programming
Parallel Reasoning
Parallel SAT solver
parallel satisfiability solver
Parallel Solving
Parallelism
parallelization
parameter estimation
parameter synthesis
parameter-free induction
parameterized communication topology
parameterized complexity
parametric uniformity
Parametrized systems
parity games
Parser
partial correctness
partial deduction
partial derivatives
partial equivalence checking problem
Partial Equivalence Relations
partial evaluation
partial order reduction
Partially Ordered Sets
passivation
Passivization
Path
Path Based SCC Algorithms
pattern
Pattern calculus
Pattern matching
patterns
PCA
PCFG
PCR
PCTL
pdr
peak decreasingness
Pearl's virtual evidence method
Pebble walking automata
pedagogy
perfect masking
performance
performance evaluation
performance prediction
periodically iterated morphisms
Permissive-upgrade
permutation equivalence
Permutation Flowshop Scheduling Problem
Permutation lemmas
Persistency
Personality Traits
personalized PageRank
Petri nets
PGAS
pGCL
pharmacogenomics
Phase Conjugating Mirror
pi calculus
PIDE
Pigeonhole Principle
ping-pong protocols
planning
Planning and Pseudo-boolean Optimization
Planning as Satisfiability
planted distribution
Plausibility Rankings
pointer arithmetic
Pointer Machines
polarisation
policy composition
policy iteration
Polya
Polymer Reaction Network
polymorphic typing
polymorphism
polynomial
polynomial approximations
polynomial calculus
polynomial constraints
Polynomial Contraints
Polynomial Hierarchy
polynomial interpretations
Polynomial runtime complexity
polynomial space
polynomial systems
polynomial time
polynomial time algorithm
population size in relational models
Portability
Portfolio
Portfolio Solving
Possibilistic networks
PosSLP
Power managment designs
predicate abstraction
predicate discovery
predicate transformer
predicativity
predictive analytics
Preference
preference handling
preferences
Preferential
prefix grammar
prefix probability
Pregroups
premature convergence
Preorders
preprocessing
Presburger arithmetic
preservation
preservation theorems
preserving soundness
presheaf
Presheaf semantics
primal infon logic
prime critical pairs
prime implicates
prime impliquates
prime network
PRISM
Privacy
Privacy & Information Flow
privacy foundation
Privacy policy compliance
Probabilistic BMC
probabilistic conditional
Probabilistic Description Logic
Probabilistic grammar
Probabilistic hybrid automaton
probabilistic logic
Probabilistic Logic Programming
Probabilistic Logic Programs
probabilistic logics
probabilistic model checking
Probabilistic Model Checking Case Studies
probabilistic models
probabilistic reasoning
probabilistic satisfiability (PSAT)
probabilistic systems
Probability
probability box
Proble-specific Solver
ProbLog
procedural attachment
procedural program
procedural semantics
Process Adaptation
process algebra
Process calculi
process calculus
Process Engineering
producer/consumer model
Product Modal Logics
Product Programs
production rule systems
program analysis
program equivalence
Program extraction
Program Logic
program logics
program refactoring
Program repair
program schematology
program semantics
program specialization
program synthesis
program transformation
program transformations
program verification
Programmable logic controllers
Programming
programming framework
progression
progression of basic action theories
Projection
Prolog
Prolog implementation
Prolog System
Prolog to Java translation
proof
proof assistants
proof automation
proof checker
proof checking
proof complexity
proof compression
proof construction
proof equivalence problem
proof net
proof nets
proof nets retraction
Proof of topological properties
Proof of total correctness
Proof pearl
proof procedure
proof procedure language
proof search
Proof strategy language
proof terms
proof theory
proof-nets
proof-search
Proof-Theoretic Semantics
Proof-Theory
Proofs
proofs without syntax
PROP
PROP quasi-order
Property Directed Reachability
property-driven
Property-driven reachability
propositional assignments
propositional closure
Propositional dynamic logic
propositional logics
Propositional model counting
Propositional Normal Modal logics
Propositional proof system
Propositional Resolution
Propositional Satisfiability
ProPPR
Protege
proto-differential nets
protocol analysis
Protocol Security
Protocol Suite
provenance
Prover IDE
pseudo-Boolean Constraints
pseudorandom constructions
psychological validation
PTIME dialects
PTQ-fragment
Public key crypto
Pudlak rules
pure lambda-calculus
Pure Nash Equilibria
Pure Type Systems
Pushdown Automata
Pushdown Systems
Q
Q-Resolution
QBF
QBF of bounded treewidth
QBF-solver
qualitative algebras
qualitative constraint networks
Qualitative reasoning
qualitative spatial reasoning
Quantified Boolean Formula
Quantified Boolean Formulas
quantified constraint satisfaction
Quantified Formulas
quantifier elimination
Quantifier Instantiation
quantifier-free
Quantifiers
quantifiers and theories
Quantitative analysis
quantitative information flow
Quantitative Model-Checking
quantitative objectives
Quantitative security
Quantitative semantics
quantitative synthesis
quantum computation
Quantum Computing
Quantum Flip Gate
Quantum Optics
Quasi-Invariants
query answering
query entailment
Query Evaluation
query generation
query languages
query optimization
query plan generation
query rewriting
R
R-calculus
Ramsey Theorem
Random CNFs
random satisfiability
Randomized Bubble Sort
Randomized Search
rank
Ranking Function
ranking queries
rational closure
rational relations
Rational Terms
rationality
RDF
RDFS
RDMA
Reachability
reachability analysis
Reachability assertions
reachability games
Reachability problem
Reaction enumerator
Reaction Networks
Reactive reasoning
reactive synthesis
reactive systems
real algebra
real analysis
real inequalities
Real number computation
Real Turing Machine
realizability
Realizability semantics
realization
reasoner
reasoner performance
reasoners
Reasoning
reasoning about action and change
reasoning about actions
reasoning about actions and change
reasoning about knowledge and action
reasoning about knowledge and belief
Reasoning under uncertain inputs
Reconfiguration
reconfiguration problem
Recurrence relation
recursion
Recursive path ordering
Recursive Types
reduction to SAT
Reductions
Reductions to SAT
redundancy
refinement
refinement relation
Refinement types
Refining partial structures
reflection
Refutation
region connection calculus
Regional Energy Planning
regression test selection
regression verification
Regular cost functions
regular expression equivalence
regular expressions
Regular formulas
regular languages
Regular Languages of Infinite Words
Regular Languages of Words
regular path queries
relational
relational conditional
Relational dual tableau system
relational logic
relational logistic regression
relational probabilistic models
relational semantics
Relationship between deduction methods
relative clauses
relative error
relative termination
relaxed instance queries
relaxed memory models
Relaxed Queries
Relevance
relevance logic
Relevance Theory
reliable constraint reasoning
remote code execution
Reordering
Repair Decomposition
Repairing
requirement traceability
residual number system
resolution
resolution and superposition
resolution complexity
resolution method
Resolution rules
resolution space
resolution width
Resource Usage Analysis
Resource λ-calculus
resource-bounded search
Retyping functions
Reversible computing
revision
revision calculus
rewards
Rewrite Systems
Rewriting
Rewriting in action logic
rewriting logic
Rewriting system
rewriting techniques
rhythm representation
rich
risk
Risk Awareness
risk communication
risk mitigation
Risk Propensity
RL systems
robotics
Robots
robust quantitative objectives
Rough DL
rough sets
RTL
rule safety
Rule transposition
rule-based models
Rule-Labelling
rules
runtime analysis
Runtime Complexity
Runtime Complexity Analysis
Runtime monitoring
S
s
Safety
safety-critical real-time systems
SAT
SAT application
SAT competitions
SAT encoding
SAT encoding of combinatorial problems
sat encodings
SAT Features
SAT modulo theories
SAT partitioning
SAT platform
SAT solver
SAT solvers
SAT solving
SAT under Assumptions
SatELite
Satifiability Modulo Theory
satisfiability
Satisfiability in Alternating-time Temporal Logic
Satisfiability Modulo Theories
Satisfiability problem
Satisfiability procedure
saturation
saturation algorithm
Saturation Algorithms
Saturation Procedures
Scala
Scalability
Scalable Unbounded Verification
scalar implicature
scale-free networks
Sceptical reasoning
scheduling
Schematic Proof
Scope-Bounding
Scott data types
Scripting Language
scripting languages
Sea Urchin Development
search
search problems
second-order logic
Second-order quantifier elimination
secrecy
secret-sharing
Secure Electronic Voting
secure equilibria
secure multi-execution
Secure multiparty computation
secure services
secure sets
Secure Web Bulletin Board
Security
Security Awareness
Security Ceremonies
security in graphs
Security lattice
Security models
security policy
security properties
security protocols
Security Type Systems
security vulnerabilities
self organization
self regulation
Self-learning
Self-similarity
semantic guidance
semantic knowledge
Semantic Labelling
semantic rewriting
Semantic tableaux
Semantic Web
Semantic Web of Things
semantics
Semantics and pragmatics
Semantics of Aggregates
Semantics of Conditional Literals
Semantics preservation
Semantics-Based Program Transformation
semi-formal specification
semi-orders
semi-ring computation
semi-Thue system
semialgebraic
Semigroups
Semilattice Polymorphisms
Separation
separation kernel
separation kernels
separation logic
sequence of sat
Sequences of small discrepancy
sequent Calculi
sequent calculus
sequent-based systems
Sequentialization
Session integrity
session log
session types
Set Comprehension
Set Theory
set-based theorems
Set-theory
sets
Sets with atoms
shape analysis
shared-memory
sheaf
sheaf model
Sherali-Adams
SHOIQ
SHOQ
Short Paper
Shortest Path
SHQ
shuffle
side channel attacks
Side-effects
Signal-Flow-Graphs
signatures
Similarity
Similarity Measures
Simple Theory of Types
simplex
simply typed lambda calculus
simply-typed lambda-calculus
simulation
Simulation and alternating simulation
simulations
singleton arc consistency
Situation Calculus
size
Skolem/Herbrand function
skolemization
SLD-resolution
SLS
SMT
SMT solvers
SMT solving
SMT-LIB
SMT-solving
SNOMED-CT
Social Choice
social choice theory
Social Engineering
Socio-Technical Security
socratic proofs
Soft Constraints
software description
software design patterns
Software Fault Isolation
Software model checking
Software Science
Software synthesis
software test
software testing
software toolkit
Software Verification
Solver
Solver competitions
Solver Construction
Solver execution services
Solvers
solving
sorted signature
Sound Abstraction
soundness
Source code classification
Source-to-Source Transformation
SPA
space
SPARQL
SPARQL Update
Special cases of MP
specification
specification patterns
Specification Synthesis
specificity
speech act theory
splittiing
SROIQ
SSA Form
SSH
SSReflect
stability
stability analysis
stable model semantics
Staged Computation
standard completness
standard reasoning
Standards
state space analysis
State-boundedness
statecharts
Static Analysis
static checking
statistical information
Statistical Relational Artificial Intelligence
Statistical Relational Learning
step-indexing
stochastic chemical kinetics
Stochastic Logic Programs
stochastic processes
Stochastic satisfiability modulo theories
Story Telling
story understanding
strand spaces
Strategic Environmental Assessment
strategic interaction
strategies
strategy development
Strategy Logic
streams
string
string constraints
string processing
string rewriting
String solvers
String transducers
strings
Strong Embedding
Strong Equivalence
strong negation
Strong normalisation
strong normalization
strong termination
Strong Update
Strongest Necessary Conditions
Strongly Connected Components
structural completeness
structural decompositions
structural equations
Structural tractability
structure learning
Structure preserving
structured code generators
structured proof
structures of bounded degree
sub-classical logics
subexponential
subgame perfect
Subset-simulation
substitutability
substitution
substitutions
substructural logic
Substructural Types
Subterm selection
subtyping
subword complexity
Succinctness
sudoku puzzle
Sunburst Tree
supercompilation
superposition
superposition calculus
support function
supported model semantics
Surveillance
Symbolic analysis
Symbolic Automata
symbolic computation
symbolic execution
Symbolic model
Symbolic Model Checking
symbolic orthogonal projections
symbolic simulation
Symbolic Time bounds
symbolic transducers
symmetric encryption
Symmetric monoidal categories
symmetry
synaptic vesicle cycle
Syntactic cut-elimination
syntax-semantics interface
synthesis
synthetic biology
System description
System F
System T
Systematic Testing
SystemC
Systems Biology
T
Tableau
Tableau Algorithm
Tableau Algorithms
tableau reasoning
Tableau-based Decision Methods
tableaux
Tableaux calculi
tableaux calculus
tabled abduction
Tabling
Tactics
tagged hardware
Tarski
task planning
Taylor expansion
taylor series
TBox Revision
TC_0
teaching
technical vision
Technology Adoption
telecommunication protocol
Temperature puzzle
templates domain
temporal attributes
Temporal Description Logics
temporal logic
temporal logics
Temporal projection
temporal querying
Temporal Reasoning
temporal stable models
Term
term algebra
term indexing
term ordering
term representation
Term Rewrite Systems
term rewriting
Term rewriting system
Term rewriting systems
Term Size Analysis
termination
termination analysis
Termination proof
Termination Theorem
terminologies
test data generation
testing
teyjus system
tgds
the B I monoid
The Correctnes Of Transformations
The dependency pair framework
the game of Alonzo
the pcp theorem
theorem prover technology
theorem provers
theorem proving
theorem-prover implementation
Theorem-Proving
Theorema
Theory approximation
Theory combination
Theory of arrays
Theory of Strings
Threat models
Three-valued Lukasiewicz Logic
three-valued semantics
Three-valued Łukasiewicz Logic
tiling problem
time
Time Travel
timed verification
timing analysis
Timing Attacks
Timing of Security Decisions
TLS
token machines
Tool
Tool description
Tool paper
tool support
Tools
top-down query-answering
Topological vector spaces
topology
Tor
Total Space
TPTP
TPTP Process Instruction language
tracing
tractability boundaries
tractability theory
transaction
transaction logic
transactions
Transfer
transfer of meta-theory
transfinite reduction
Transformation Analysis
transformation system
Transformations
transformer
transition system
Transitive closure
Translation
Translation Validation
translations
TReasoner
tree automata
tree automaton
Tree-Automata
trees
treewidth
trimming
Trip Count Prediction
true concurrency
tupled pregroup grammars
Tupling
Turing machine
Turing machines
twelf
two-dimensional partial map
two-player games
two-player games on weighted graphs
two-variable logic
two-variable logics
two-way automata
Type
Type and effect system
Type Classes
Type containment
type framework
type inference
Type Introduction
Type Isomorphism
type preservation
type system
Type systems
type theory
type-based theorems
Typed lambda calculus
typed lambda-calculus
Types
typical-case complexity
typing
U
Ubiquitous computing
ultimately-periodic sets
uncertainty
uncertainty reasoning
unfolding
Unfolding graph rewriting
unfoldings
Unification
Unification type
Uniform Interpolation
Uniform interpolation and forgetting
uniform termination
unifying theories of programming
unintentional
Union of non-disjoint theories
Universal algebra
Universal composability
universes
unraveling
Unravelings
unsatisfiability proof
unwinding relation
up-to techniques
update
updates
upper bound
Usability
usable rules
Usable Security
user interface
user interfaces
user interfaces for interactive theorem provers
user perception
Users
Utility Theory
V
vagueness
Validation
Validation of Numerical Programs
validity
Vampire
Variable Elimination
Variational Bayes
VCG
Vector addition systems
Vector Space Semantics
verification
verification condition generator
verification of requirement specification
Verification tools
Verified Software
verifying compiler
veriT
Vickrey's theorem
Video Games
Virtual Characters
virtual machine
virtual substitution
virtual term substitution
Visibly Pushdown Languages
visual and spatial cognition and computation
Visual Languages
Visual query formulation
Visual query formulation interface
visualization
vulnerability
W
W[2]-hardness
Wave-style Token machines
Weak Completion Semantics
weak constraints
weak EXP hierarchy
weak memory
weak memory models
weak monadic second-order
weak normalization
weak pigeonhole principle
weak reduction
weakly shallow
Web authentication
Web of Linked Data
web programming
web scripts
web service choreography
Website Fingerprinting
weight
Weighted first-order logic
Weighted Model Counting
weights
well-founded model
Well-Founded Semantics
Well-structured pushdown systems
well-supported models
wellorder
while-programs
width
Wiener measure
Winograd Schema Challenge
Winograd Schemas
witness
WMSO
word equations
world view
wrap ambiguity
X
XML
XML and graph data
XML Processing
XML Schema
xpath
XSB Prolog
XSD
Z
Z-Transform
zero-knowledge proofs
Disclaimer | Powered by EasyChair Smart Program