The document discusses tabling of structured data in Prolog. It presents a workaround that uses indexing and program transformation to achieve efficient tabling. The workaround represents terms as sets of facts using unique integers as pointers. This avoids copying structure during tabling and enables constant time lookups. Examples showing the workaround applied to edit distance and hidden Markov models are provided. Benchmarking shows the workaround provides O(1) time and space complexity compared to O(n2) for naive tabling of structured data.
This presentation is a review of the NoSQL spaces I did for the X Jornades de Programari Lliure in Barcelona.
You will see a complete review of the NoSQL movement, use cases, technology review, an special review of what are the Graph Databases. And more....
Special thanks to @Hagenburger, @sbitxu, @jannis and the inspiration of the big @jimwebber and the amazing community.
IJERD(www.ijerd.com)International Journal of Engineering Research and Develop...IJERD Editor
This document summarizes and compares two algorithms for XML tree pattern matching: TwigStack and TwigStackList. TwigStack avoids generating unnecessary intermediate results and scanning irrelevant portions of XML documents. However, it maintains redundancy and may not retrieve large queries efficiently. TwigStackList improves efficiency for large queries by combining TwigStack with lists to reduce redundancy. It operates in two phases: generating partial solutions along individual paths, then merging the solutions. Experimental results show TwigStackList significantly improves performance for complex or high selectivity queries.
Paper talk @ EDBT'10: Fine-grained and efficient lineage querying of collecti...Paolo Missier
The document discusses fine-grained provenance tracking of workflow data products. It presents a functional model for collection-oriented workflow processing that models workflows operating on nested collections. This model generalizes simple iteration to arbitrary collection depths and handles multiple input collections through a generalized cross product operation. The model aims to enable efficient provenance querying by traversing the workflow graph instead of the potentially larger provenance graph.
Boosted Tree-based Multinomial Logit Model for Aggregated Market DataJay (Jianqiang) Wang
This document presents a boosted tree-based multinomial logit model for estimating aggregated market demand from mobile computer sales data. It discusses challenges in modeling high-dimensional choice data with interactions among attributes and price. The proposed model uses gradient boosted trees to flexibly estimate utility functions without specifying a functional form, allowing for varying coefficient and nonparametric specifications. The model is shown to outperform elastic net regularized estimation on Australian mobile computer sales data, with the nonparametric model achieving the best test set performance while capturing complex attribute interactions.
The document discusses subspace indexing on Grassmannian manifolds for large scale visual identification. It proposes using local subspace models built on neighborhoods defined by queries, but notes issues with computational complexity and lack of optimality. It then introduces Grassmannian and Stiefel manifolds to characterize subspace similarity and define distances. A model hierarchical tree is proposed to index subspaces through iterative merging based on distances on the Grassmannian manifold.
This document summarizes machine learning methods for text and web data mining. It discusses several machine learning techniques including neural networks, probabilistic models, and other methods. It provides examples of applying these techniques to tasks like text categorization, topic word extraction from documents, and customer analysis from web data. Experimental results on text and web datasets demonstrate the effectiveness of techniques like Helmholtz machines, Bayesian networks, and latent variable models for text and web mining applications.
This presentation is a review of the NoSQL spaces I did for the X Jornades de Programari Lliure in Barcelona.
You will see a complete review of the NoSQL movement, use cases, technology review, an special review of what are the Graph Databases. And more....
Special thanks to @Hagenburger, @sbitxu, @jannis and the inspiration of the big @jimwebber and the amazing community.
IJERD(www.ijerd.com)International Journal of Engineering Research and Develop...IJERD Editor
This document summarizes and compares two algorithms for XML tree pattern matching: TwigStack and TwigStackList. TwigStack avoids generating unnecessary intermediate results and scanning irrelevant portions of XML documents. However, it maintains redundancy and may not retrieve large queries efficiently. TwigStackList improves efficiency for large queries by combining TwigStack with lists to reduce redundancy. It operates in two phases: generating partial solutions along individual paths, then merging the solutions. Experimental results show TwigStackList significantly improves performance for complex or high selectivity queries.
Paper talk @ EDBT'10: Fine-grained and efficient lineage querying of collecti...Paolo Missier
The document discusses fine-grained provenance tracking of workflow data products. It presents a functional model for collection-oriented workflow processing that models workflows operating on nested collections. This model generalizes simple iteration to arbitrary collection depths and handles multiple input collections through a generalized cross product operation. The model aims to enable efficient provenance querying by traversing the workflow graph instead of the potentially larger provenance graph.
Boosted Tree-based Multinomial Logit Model for Aggregated Market DataJay (Jianqiang) Wang
This document presents a boosted tree-based multinomial logit model for estimating aggregated market demand from mobile computer sales data. It discusses challenges in modeling high-dimensional choice data with interactions among attributes and price. The proposed model uses gradient boosted trees to flexibly estimate utility functions without specifying a functional form, allowing for varying coefficient and nonparametric specifications. The model is shown to outperform elastic net regularized estimation on Australian mobile computer sales data, with the nonparametric model achieving the best test set performance while capturing complex attribute interactions.
The document discusses subspace indexing on Grassmannian manifolds for large scale visual identification. It proposes using local subspace models built on neighborhoods defined by queries, but notes issues with computational complexity and lack of optimality. It then introduces Grassmannian and Stiefel manifolds to characterize subspace similarity and define distances. A model hierarchical tree is proposed to index subspaces through iterative merging based on distances on the Grassmannian manifold.
This document summarizes machine learning methods for text and web data mining. It discusses several machine learning techniques including neural networks, probabilistic models, and other methods. It provides examples of applying these techniques to tasks like text categorization, topic word extraction from documents, and customer analysis from web data. Experimental results on text and web datasets demonstrate the effectiveness of techniques like Helmholtz machines, Bayesian networks, and latent variable models for text and web mining applications.
Constraints and Global Optimization for Gene Prediction Overlap ResolutionChristian Have
We apply constraints and global optimization to the problem of restricting overlapping of gene predictions for prokaryotic genomes. We investigate existing heuristic methods and show how they may be expressed using Constraint Handling Rules. Furthermore, we integrate existing methods in a global optimization procedure expressed as probabilistic model in the PRISM language. This approach yields an optimal (highest scoring) subset of predictions that satisfy the constraints. Experimental results indicate accuracy comparable to the heuristic approaches.
This document describes an animal that eats over 1,000 species, lives in crowded and warm places like New York, and open grassy and field areas. It is a scavenger that is quick, hygienic, has four legs, a tail, and comes in different colors.
The document discusses several key concepts in Christianity, including the Holy Trinity consisting of God the Father, Son, and Holy Spirit; Jesus Christ as both fully man and fully God; God creating nature and humans out of love; the Bible providing teachings about God; the importance of prayer; Heaven and Earth representing God's love and freewill; and the Holy Spirit guiding prophets and believers to truth.
The document is a first-person description of an animal written by the animal itself. It provides clues about the animal's habitat, diet, whether it is an herbivore, carnivore, scavenger or omnivore, and three things that make it special. The animal does not reveal its identity, instead prompting the reader to guess what animal it is based on the clues and description provided.
The document describes a warm grassland animal from Australia that carries its babies in a pouch and jumps instead of running. It comes in shades of brown and stands tall on two legs. The animal is identified as a kangaroo.
Efficient Probabilistic Logic Programming for Biological Sequence AnalysisChristian Have
This document introduces probabilistic logic programming and its applications to biological sequence analysis. It discusses using probabilistic logic programming to build models for tasks like gene finding in DNA sequences. These models can represent relationships between sequence features and embed domain constraints while reasoning under uncertainty. The document outlines the author's research questions around using this approach for biological sequence analysis and their approach of building applications, abstractions, and optimizations to evaluate it. It provides background on prokaryotic gene finding tasks and probabilistic logic programming languages like PRISM.
Modern enterprise data—tracking key performance indicators like conversions or click-throughs—exhibits a pathologically high dimensionality, which requires re-thinking data representation to make analysis tractable.
QuickCheck is a lightweight tool for randomly testing Haskell programs. It uses type classes like Arbitrary and CoArbitrary to generate random test cases for data types and functions. Properties to check are specified using a domain specific language embedded in Haskell. Case studies show it can find errors in programs like unification and pretty printing. While lightweight, QuickCheck has limitations like difficulty testing non-terminating programs and formal specifications are still needed to fully check programs.
This document discusses generative adversarial networks (GANs) and their applications. It begins with an overview of generative models including variational autoencoders and GANs. GANs use two neural networks, a generator and discriminator, that compete against each other in a game theoretic framework. The generator learns to generate fake samples to fool the discriminator, while the discriminator learns to distinguish real and fake samples. Applications discussed include image-to-image translation using conditional GANs to map images from one domain to another, and text-to-image translation using GANs to generate images from text descriptions.
It's a well-known fact that the best explanation of a simple model is the model itself. But often we use complex models, such as ensemble methods or deep networks, so we cannot use the original model as its own best explanation because it is not easy to understand.
In the context of this topic, we will discuss how methods for interpreting model predictions work and will try to understand practical value of these methods.
Lessons learned from designing a QA Automation for analytics databases (big d...Omid Vahdaty
Have a big data product / database / DBMS? need to test it? don't know where to start? some things to consider while you design your Automation QA.
Link to Video
https://www.youtube.com/watch?v=MlT4pP7BGFQ
Inductive Triple Graphs: A purely functional approach to represent RDFJose Emilio Labra Gayo
Slides of my presentation on 3rd International Workshop on Graph Structures for Knowledge Representation, part of the International Joint Conference on Artificial Intelligence, Beijing, China. 4 August 2013
PL/CUDA allows writing user-defined functions in CUDA C that can run on a GPU. This provides benefits for analytics workloads that can utilize thousands of GPU cores and wide memory bandwidth. A sample logistic regression implementation in PL/CUDA showed a 350x speedup compared to a CPU-based implementation in MADLib. Logistic regression performs binary classification by estimating weights for explanatory variables and intercept through iterative updates. This is well-suited to parallelization on a GPU.
Machine Learning Applications in Subsurface Analysis: Case Study in North SeaYohanes Nuwara
This was presented in the International Geosciences Symposium organized by Christ College in Kerala, India. In this presentation, I shared one of my works on the prediction of synthetic sonic log using machine learning in Volve Field, North Sea.
This is an introductory learn-up on Machine Learning using Python. You get to understand the basic theory of Machine Learning and also the practical implementation.
Lab notebook can be found here : https://github.com/opencubelabs
Deep Convolutional GANs - meaning of latent spaceHansol Kang
DCGAN은 GAN에 단순히 conv net을 적용했을 뿐만 아니라, latent space에서도 의미를 찾음.
DCGAN 논문 리뷰 및 PyTorch 기반의 구현.
VAE 세미나 이슈 사항에 대한 리뷰.
my github : https://github.com/messy-snail/GAN_PyTorch
[참고]
https://github.com/znxlwm/pytorch-MNIST-CelebA-GAN-DCGAN
https://github.com/taeoh-kim/Pytorch_DCGAN
Radford, Alec, Luke Metz, and Soumith Chintala. "Unsupervised representation learning with deep convolutional generative adversarial networks." arXiv preprint arXiv:1511.06434 (2015).
Precog & MongoDB User Group: Skyrocket Your Analytics MongoDB
earn how to do advanced analytics with the Precog data science platform on your MongoDB database. It's free to download the Precog file and after installing, you'll be on your way to analyzing all the data in your MongoDB database, without forcing you to export data into another tool or write any custom code. Learn more here: www.precog.com/mongodb
Pregel: A System For Large Scale Graph ProcessingRiyad Parvez
Pregel is a distributed system for large-scale graph processing that uses a vertex-centric programming model based on Google's Bulk Synchronous Parallel (BSP) framework. In Pregel's message passing model, computations are organized into supersteps where each vertex performs computations and sends messages to other vertices. A barrier synchronization occurs between supersteps. Pregel provides fault tolerance through checkpointing and the ability to dynamically mutate graph topology during processing. The paper demonstrates that Pregel can efficiently process large graphs and scale computation near linearly with the size of the graph.
Software tookits for machine learning and graphical modelsbutest
This document summarizes machine learning software for graphical models. It discusses discriminative models for independent data, conditional random fields for dependent data, generative models for unsupervised learning, and Bayesian models. It provides an overview of software for inference, learning, and Bayesian inference in graphical models.
Constraints and Global Optimization for Gene Prediction Overlap ResolutionChristian Have
We apply constraints and global optimization to the problem of restricting overlapping of gene predictions for prokaryotic genomes. We investigate existing heuristic methods and show how they may be expressed using Constraint Handling Rules. Furthermore, we integrate existing methods in a global optimization procedure expressed as probabilistic model in the PRISM language. This approach yields an optimal (highest scoring) subset of predictions that satisfy the constraints. Experimental results indicate accuracy comparable to the heuristic approaches.
This document describes an animal that eats over 1,000 species, lives in crowded and warm places like New York, and open grassy and field areas. It is a scavenger that is quick, hygienic, has four legs, a tail, and comes in different colors.
The document discusses several key concepts in Christianity, including the Holy Trinity consisting of God the Father, Son, and Holy Spirit; Jesus Christ as both fully man and fully God; God creating nature and humans out of love; the Bible providing teachings about God; the importance of prayer; Heaven and Earth representing God's love and freewill; and the Holy Spirit guiding prophets and believers to truth.
The document is a first-person description of an animal written by the animal itself. It provides clues about the animal's habitat, diet, whether it is an herbivore, carnivore, scavenger or omnivore, and three things that make it special. The animal does not reveal its identity, instead prompting the reader to guess what animal it is based on the clues and description provided.
The document describes a warm grassland animal from Australia that carries its babies in a pouch and jumps instead of running. It comes in shades of brown and stands tall on two legs. The animal is identified as a kangaroo.
Efficient Probabilistic Logic Programming for Biological Sequence AnalysisChristian Have
This document introduces probabilistic logic programming and its applications to biological sequence analysis. It discusses using probabilistic logic programming to build models for tasks like gene finding in DNA sequences. These models can represent relationships between sequence features and embed domain constraints while reasoning under uncertainty. The document outlines the author's research questions around using this approach for biological sequence analysis and their approach of building applications, abstractions, and optimizations to evaluate it. It provides background on prokaryotic gene finding tasks and probabilistic logic programming languages like PRISM.
Modern enterprise data—tracking key performance indicators like conversions or click-throughs—exhibits a pathologically high dimensionality, which requires re-thinking data representation to make analysis tractable.
QuickCheck is a lightweight tool for randomly testing Haskell programs. It uses type classes like Arbitrary and CoArbitrary to generate random test cases for data types and functions. Properties to check are specified using a domain specific language embedded in Haskell. Case studies show it can find errors in programs like unification and pretty printing. While lightweight, QuickCheck has limitations like difficulty testing non-terminating programs and formal specifications are still needed to fully check programs.
This document discusses generative adversarial networks (GANs) and their applications. It begins with an overview of generative models including variational autoencoders and GANs. GANs use two neural networks, a generator and discriminator, that compete against each other in a game theoretic framework. The generator learns to generate fake samples to fool the discriminator, while the discriminator learns to distinguish real and fake samples. Applications discussed include image-to-image translation using conditional GANs to map images from one domain to another, and text-to-image translation using GANs to generate images from text descriptions.
It's a well-known fact that the best explanation of a simple model is the model itself. But often we use complex models, such as ensemble methods or deep networks, so we cannot use the original model as its own best explanation because it is not easy to understand.
In the context of this topic, we will discuss how methods for interpreting model predictions work and will try to understand practical value of these methods.
Lessons learned from designing a QA Automation for analytics databases (big d...Omid Vahdaty
Have a big data product / database / DBMS? need to test it? don't know where to start? some things to consider while you design your Automation QA.
Link to Video
https://www.youtube.com/watch?v=MlT4pP7BGFQ
Inductive Triple Graphs: A purely functional approach to represent RDFJose Emilio Labra Gayo
Slides of my presentation on 3rd International Workshop on Graph Structures for Knowledge Representation, part of the International Joint Conference on Artificial Intelligence, Beijing, China. 4 August 2013
PL/CUDA allows writing user-defined functions in CUDA C that can run on a GPU. This provides benefits for analytics workloads that can utilize thousands of GPU cores and wide memory bandwidth. A sample logistic regression implementation in PL/CUDA showed a 350x speedup compared to a CPU-based implementation in MADLib. Logistic regression performs binary classification by estimating weights for explanatory variables and intercept through iterative updates. This is well-suited to parallelization on a GPU.
Machine Learning Applications in Subsurface Analysis: Case Study in North SeaYohanes Nuwara
This was presented in the International Geosciences Symposium organized by Christ College in Kerala, India. In this presentation, I shared one of my works on the prediction of synthetic sonic log using machine learning in Volve Field, North Sea.
This is an introductory learn-up on Machine Learning using Python. You get to understand the basic theory of Machine Learning and also the practical implementation.
Lab notebook can be found here : https://github.com/opencubelabs
Deep Convolutional GANs - meaning of latent spaceHansol Kang
DCGAN은 GAN에 단순히 conv net을 적용했을 뿐만 아니라, latent space에서도 의미를 찾음.
DCGAN 논문 리뷰 및 PyTorch 기반의 구현.
VAE 세미나 이슈 사항에 대한 리뷰.
my github : https://github.com/messy-snail/GAN_PyTorch
[참고]
https://github.com/znxlwm/pytorch-MNIST-CelebA-GAN-DCGAN
https://github.com/taeoh-kim/Pytorch_DCGAN
Radford, Alec, Luke Metz, and Soumith Chintala. "Unsupervised representation learning with deep convolutional generative adversarial networks." arXiv preprint arXiv:1511.06434 (2015).
Precog & MongoDB User Group: Skyrocket Your Analytics MongoDB
earn how to do advanced analytics with the Precog data science platform on your MongoDB database. It's free to download the Precog file and after installing, you'll be on your way to analyzing all the data in your MongoDB database, without forcing you to export data into another tool or write any custom code. Learn more here: www.precog.com/mongodb
Pregel: A System For Large Scale Graph ProcessingRiyad Parvez
Pregel is a distributed system for large-scale graph processing that uses a vertex-centric programming model based on Google's Bulk Synchronous Parallel (BSP) framework. In Pregel's message passing model, computations are organized into supersteps where each vertex performs computations and sends messages to other vertices. A barrier synchronization occurs between supersteps. Pregel provides fault tolerance through checkpointing and the ability to dynamically mutate graph topology during processing. The paper demonstrates that Pregel can efficiently process large graphs and scale computation near linearly with the size of the graph.
Software tookits for machine learning and graphical modelsbutest
This document summarizes machine learning software for graphical models. It discusses discriminative models for independent data, conditional random fields for dependent data, generative models for unsupervised learning, and Bayesian models. It provides an overview of software for inference, learning, and Bayesian inference in graphical models.
TDC2017 | São Paulo - Trilha Java EE How we figured out we had a SRE team at ...tdc-globalcode
This document discusses various techniques for feature engineering raw data to improve machine learning model performance. It describes transforming data through techniques like handling missing values, aggregation, binning, encoding categorical features, and feature selection. The goal of feature engineering is to represent the underlying problem to models in a way that results in better accuracy on new data.
spaGO: A self-contained ML & NLP library in GOMatteo Grella
Introduction to spaGO, a beautiful and maintainable machine learning library written in Go designed to support relevant neural network architectures in natural language processing tasks.
Github: https://github.com/nlpodyssey/spago
Scaling Search at Lendingkart discusses how Lendingkart scaled their search capabilities to handle large increases in data volume. They initially tried scaling databases vertically and horizontally, but searches were still slow at 8 seconds. They implemented ElasticSearch for its near real-time search, high scalability, and out-of-the-box functionality. Logstash was used to seed data from MySQL and MongoDB into ElasticSearch. Custom analyzers and mappings were developed. Searches then reduced to 230ms and aggregations to 200ms, allowing the business to scale as transactional data grew 3000% and leads 250%.
Alpine Data Labs presents a deep dive into our implementation of Multinomial Logistic Regression with Apache Spark. Machine Learning Engineer DB Tsai takes us through the technical implementation details step by step. First, he explains how the state of the art Machine Learning on Hadoop is not doing fulfilling the promise of Big Data. Next, he explains how Spark is a perfect match for machine learning through their in-memory cache-ing capability demonstrating 100x performance improvement. Third, he takes us through each aspect of a multinomial logistic regression and how this is developed with Spark APIs. Fourth, he demonstrates an extension of MLOR and training parameters. Finally, he benchmarks MLOR with 11M rows, 123 features, 11% non-zero elements with a 5 node Hadoop cluster. Finally, he shows Alpine's unique visual environment with Spark and verifies the performance with the job tracker. In conclusion, Alpine supports the state of the art Cloudera and Pivotal Hadoop clusters and performances at a level that far exceeds its next nearest competitor.
Similar to Efficient Tabling of Structured Data Using Indexing and Program Transformation (20)
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
"Choosing proper type of scaling", Olena SyrotaFwdays
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
Freshworks Rethinks NoSQL for Rapid Scaling & Cost-EfficiencyScyllaDB
Freshworks creates AI-boosted business software that helps employees work more efficiently and effectively. Managing data across multiple RDBMS and NoSQL databases was already a challenge at their current scale. To prepare for 10X growth, they knew it was time to rethink their database strategy. Learn how they architected a solution that would simplify scaling while keeping costs under control.
ScyllaDB is making a major architecture shift. We’re moving from vNode replication to tablets – fragments of tables that are distributed independently, enabling dynamic data distribution and extreme elasticity. In this keynote, ScyllaDB co-founder and CTO Avi Kivity explains the reason for this shift, provides a look at the implementation and roadmap, and shares how this shift benefits ScyllaDB users.
zkStudyClub - LatticeFold: A Lattice-based Folding Scheme and its Application...Alex Pruden
Folding is a recent technique for building efficient recursive SNARKs. Several elegant folding protocols have been proposed, such as Nova, Supernova, Hypernova, Protostar, and others. However, all of them rely on an additively homomorphic commitment scheme based on discrete log, and are therefore not post-quantum secure. In this work we present LatticeFold, the first lattice-based folding protocol based on the Module SIS problem. This folding protocol naturally leads to an efficient recursive lattice-based SNARK and an efficient PCD scheme. LatticeFold supports folding low-degree relations, such as R1CS, as well as high-degree relations, such as CCS. The key challenge is to construct a secure folding protocol that works with the Ajtai commitment scheme. The difficulty, is ensuring that extracted witnesses are low norm through many rounds of folding. We present a novel technique using the sumcheck protocol to ensure that extracted witnesses are always low norm no matter how many rounds of folding are used. Our evaluation of the final proof system suggests that it is as performant as Hypernova, while providing post-quantum security.
Paper Link: https://eprint.iacr.org/2024/257
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
Must Know Postgres Extension for DBA and Developer during MigrationMydbops
Mydbops Opensource Database Meetup 16
Topic: Must-Know PostgreSQL Extensions for Developers and DBAs During Migration
Speaker: Deepak Mahto, Founder of DataCloudGaze Consulting
Date & Time: 8th June | 10 AM - 1 PM IST
Venue: Bangalore International Centre, Bangalore
Abstract: Discover how PostgreSQL extensions can be your secret weapon! This talk explores how key extensions enhance database capabilities and streamline the migration process for users moving from other relational databases like Oracle.
Key Takeaways:
* Learn about crucial extensions like oracle_fdw, pgtt, and pg_audit that ease migration complexities.
* Gain valuable strategies for implementing these extensions in PostgreSQL to achieve license freedom.
* Discover how these key extensions can empower both developers and DBAs during the migration process.
* Don't miss this chance to gain practical knowledge from an industry expert and stay updated on the latest open-source database trends.
Mydbops Managed Services specializes in taking the pain out of database management while optimizing performance. Since 2015, we have been providing top-notch support and assistance for the top three open-source databases: MySQL, MongoDB, and PostgreSQL.
Our team offers a wide range of services, including assistance, support, consulting, 24/7 operations, and expertise in all relevant technologies. We help organizations improve their database's performance, scalability, efficiency, and availability.
Contact us: info@mydbops.com
Visit: https://www.mydbops.com/
Follow us on LinkedIn: https://in.linkedin.com/company/mydbops
For more details and updates, please follow up the below links.
Meetup Page : https://www.meetup.com/mydbops-databa...
Twitter: https://twitter.com/mydbopsofficial
Blogs: https://www.mydbops.com/blog/
Facebook(Meta): https://www.facebook.com/mydbops/
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
"Scaling RAG Applications to serve millions of users", Kevin GoedeckeFwdays
How we managed to grow and scale a RAG application from zero to thousands of users in 7 months. Lessons from technical challenges around managing high load for LLMs, RAGs and Vector databases.
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
High performance Serverless Java on AWS- GoTo Amsterdam 2024Vadym Kazulkin
Java is for many years one of the most popular programming languages, but it used to have hard times in the Serverless community. Java is known for its high cold start times and high memory footprint, comparing to other programming languages like Node.js and Python. In this talk I'll look at the general best practices and techniques we can use to decrease memory consumption, cold start times for Java Serverless development on AWS including GraalVM (Native Image) and AWS own offering SnapStart based on Firecracker microVM snapshot and restore and CRaC (Coordinated Restore at Checkpoint) runtime hooks. I'll also provide a lot of benchmarking on Lambda functions trying out various deployment package sizes, Lambda memory settings, Java compilation options and HTTP (a)synchronous clients and measure their impact on cold and warm start times.
From Natural Language to Structured Solr Queries using LLMsSease
This talk draws on experimentation to enable AI applications with Solr. One important use case is to use AI for better accessibility and discoverability of the data: while User eXperience techniques, lexical search improvements, and data harmonization can take organizations to a good level of accessibility, a structural (or “cognitive” gap) remains between the data user needs and the data producer constraints.
That is where AI – and most importantly, Natural Language Processing and Large Language Model techniques – could make a difference. This natural language, conversational engine could facilitate access and usage of the data leveraging the semantics of any data source.
The objective of the presentation is to propose a technical approach and a way forward to achieve this goal.
The key concept is to enable users to express their search queries in natural language, which the LLM then enriches, interprets, and translates into structured queries based on the Solr index’s metadata.
This approach leverages the LLM’s ability to understand the nuances of natural language and the structure of documents within Apache Solr.
The LLM acts as an intermediary agent, offering a transparent experience to users automatically and potentially uncovering relevant documents that conventional search methods might overlook. The presentation will include the results of this experimental work, lessons learned, best practices, and the scope of future work that should improve the approach and make it production-ready.
GraphRAG for LifeSciences Hands-On with the Clinical Knowledge Graph
Efficient Tabling of Structured Data Using Indexing and Program Transformation
1. Efficient Tabling of Structured Data
Using Indexing and Program Transformation
Christian Theil Have and Henning Christiansen
Research group PLIS: Programming, Logic and Intelligent Systems
Department of Communication, Business and Information Technologies
Roskilde University, P.O.Box 260, DK-4000 Roskilde, Denmark
PADL in Philadelphia, January 23, 2012
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
2. Outline
1 Motivation and background
The trouble with tabling of structured data
2 A workaround implemented in Prolog
Examples
Example: Edit Distance
Example: Hidden Markov Model in PRISM
3 An automatic program transformation
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
3. Motivation and background
Motivation
In the LoSt project we explore the use of Probabilistic Logic
programming (with PRISM) for biological sequence analysis.
We had some problems analyzing very long sequences..
.. and identified the culprit: Tabling of structured data.
Inspired by earlier work by Christiansen and Gallagher which address a
similar problem related to tabling non-discrimininatory arguments.
Henning Christiansen, John P. Gallagher
Non-discriminating Arguments and their Uses.
ICLP 2009.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
4. Motivation and background The trouble with tabling of structured data
The trouble with tabling of structured data
Tabling in logic programming is an established technique which,
can give a significant speed-up of program execution.
make it easier to write efficient programs in a declarative style.
is similar to memoization in functional programming.
The idea:
The system maintains a table of calls and their answers.
when a new call is entered, check if it is stored in the table
if so, use previously found solution.
Tabling is included in several recognized Prolog systems such as B-Prolog,
YAP and XSB.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
5. Motivation and background The trouble with tabling of structured data
The trouble with tabling of structured data
An innocent looking call: last([1,2,3,4,5],X)
predicate: last/2 last([1,2,3,4,5],X)
last([X],X). last([1,2,3,4],X)
last([_|L],X) :- last([1,2,3],X)
last(L,X). last([1,2],X)
last([1],X)
Traverses a list to find
the last element. call table
Time/space complexity: last([1,2,3,4,5],X).
O(n). last([1,2,3,4],X).
last([1,2,3],X).
If we table last/2:
last([1,2],X).
n + n − 1 + n − 2...1
last([1],X).
≈ O(n2 ) !
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
6. Motivation and background The trouble with tabling of structured data
Wait a minute..
Tabling systems do employ some advanced techniques to avoid the
expensive copying and which may reduce memory consumption and/or
time complexity.
For instance,
B-Prolog uses hashing of goals.
XSB uses a trie data structure.
YAP uses a trie structure, which is refined into a so-called global trie
which applies a sharing strategy for common subterms whenever
possible.
These techniques may reduce space consumption, but if there is no sharing
between the tables and the actual arguments of an active call, each
execution of a call may involve a full traversal (naive copying) of its
arguments.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
7. Motivation and background The trouble with tabling of structured data
Benchmarking last/2 for B-Prolog, Yap and XSB
To investigate, we benchmarked the tabled version of last/2 for each of
the major Prolog tabling engines.
To further investigate whether performance is data dependent, we
benchmarked with both repeated data and random data.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
8. Motivation and background The trouble with tabling of structured data
Space usage, tabled last/2 (1)
b) Space usage
2000000
●
● XSB (random data) ●
● B−Prolog (random data) ●
Yap (random data)
●
XSB (repeated data)
1500000
B−Prolog (repeated data) ●
Yap (repeated data)
space usage (kilobytes)
●
●
●
1000000
●
●
●
●
●
●
500000
●
●
●
●
●
●
●
●
●
●
●
●
●
●
0
● ● ●
● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
0 500 1000 1500 2000 2500 3000
list length (N)
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
9. Motivation and background The trouble with tabling of structured data
Space usage, tabled last/2 (2)
d) Space usage expanded for the four lower curves
10000
● B−Prolog (random data)
XSB (repeated data)
B−Prolog (repeated data)
8000
Yap (repeated data)
space usage (kilobytes)
6000
4000
2000
● ●
● ●
● ●
● ●
● ●
● ●
● ●
● ●
0
0 5000 10000 15000
list length (N)
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
10. Motivation and background The trouble with tabling of structured data
Time usage, tabled last/2 (1)
a) Time usage
●
4
● XSB (random data) ●
● B−Prolog (random data) ●
Yap (random data)
●
XSB (repeated data)
B−Prolog (repeated data) ●
3
Yap (repeated data) ●
time usage (seconds)
●
●
●
●
2
●
●
●
●
●
●
1
●
●
●
● ●
●
● ●
●
●
● ●
● ●
●
● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
0
0 500 1000 1500 2000 2500 3000
list length (N)
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
11. Motivation and background The trouble with tabling of structured data
Time usage, tabled last/2 (2)
●
c) Time usage expanded for the three lower curves
●
1.0
●
● B−Prolog (random data)
XSB (repeated data) ●
Yap (repeated data) ●
0.8
●
●
time usage (seconds)
●
0.6
●
●
●
●
●
0.4
●
●
●
●
●
●
●
●
●
●
0.2
●●
●
●●
● ●
●
●●
●
●●
● ●●
●●
●●●
●●●●
0.0
0 10000 20000 30000 40000 50000
list length (N)
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
12. A workaround implemented in Prolog
A workaround implemented in Prolog
We describe a workaround giving O(1) time and space complexity for table
lookups for programs with arbitrarily large ground structured data as input
arguments.
A term is represented as a set of facts.
A subterm is referenced by a unique integer serving as an abstract
pointer.
Matching related to tabling is done solely by comparison of such
pointers.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
13. A workaround implemented in Prolog
An abstract data type
The representation is given by the following predicates which all together
can be understood as an abstract datatype.
store term( +ground-term, pointer )
The ground-term is any ground term, and the pointer
returned is a unique reference (an integer) for that term.
retrieve term( +pointer , ?functor , ?arg-pointers-list)
Returns the functor and a list of pointers to representations
of the substructures of the term represented by pointer.
full retrieve term( +pointer , ?ground-term)
Returns the term represented by pointer.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
14. A workaround implemented in Prolog
ADT properties
Property 1
It must hold for any ground term s, that the query
store term(s, P), full retrieve term(P, S),
assigns to the variable S a value identical to s.
Property 2
It must hold for any ground term s of the form f (s1 , . . . ,sn ) that
store term(s, P), retrieve term(P, F, Ss),
assigns to the variable F the symbol f , and to Ss a list of ground values
[p1 ,. . .,pn ] such that additional queries
full retrieve term(pi , Si ), i = 1, . . . , n
assign to the variables Si values identical to si .
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
15. A workaround implemented in Prolog
ADT example
Example
The following call converts the term f(a,g(b)) into its internal
representation and returns a pointer value in the variable P.
store_term(f(a,g(b)),P).
After this, the following sequence of calls will succeed.
retrieve_term(P,f,[P1,P2]),
retrieve_term(P1,a,[]),
retrieve_term(P2,g,[P21]),
retrieve_term(P21,b,[]),
full_retrieve_term(P,f(a,g(b))).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
16. A workaround implemented in Prolog
Implementation with assert
One possible way of implementing the predicates introduced above is to
have store term/2 asserting facts for the retrieve term/3 predicate
using increasing integers as pointers.
Example
The call store term(f(a,g(b)),P) considered in example 1 may assign
the value 100 to P and as a side-effect assert the following facts.
retrieve_term(100,f,[101,102]).
retrieve_term(101,a,[]).
retrieve_term(102,g,[103]).
retrieve_term(103,b,[]).
Notice that Prolog’s indexing on first arguments ensures a constant lookup
time.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
17. A workaround implemented in Prolog
Another level of abstraction: lookup pattern/2
Finally we introduce a utility predicate which may simplify the use of the
representation in application programs. It utilizes a special kind of terms,
called patterns, which are not necessarily ground and which may contain
subterms of the form lazy(variable).
lookup pattern( +pointer , +pattern)
The pattern is matched in a recursive way against the term
represented by the pointer p in the following way.
– lookup pattern(p,X) is treated as
full retrieve term(p,X).
– lookup pattern(p,lazy(X)) unifies X with p.
– For any other pattern =.. [F,X1 ,. . . ,Xn ] we call
retrieve term(p, F, [P1 ,. . .,Pn ])
followed by lookup pattern(Pi ,Xi ), i = 1, . . . , n.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
18. A workaround implemented in Prolog
A lookup pattern/2 example
Example
Continuing the previous example, we get that after the call
store term(f(a,g(b)),P).
lookup_pattern(100, f(X,lazy(Y)))
leads to X=a and Y=102.
The lookup pattern/2 predicate will be use to simplify the automatic
program transformation introduced later.
Further efficiency can be gained by compiling it out for each specific
pattern (i.e. replacing it with calls to retrieve term/2).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
19. A workaround implemented in Prolog Examples
Examples
We consider two applying the workaround to two example programs:
Edit Distance implemented in Prolog
Hidden Markov Models in PRISM
For each of these we measure the impact (in time and space) of a
transformed version using the workaround.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
20. A workaround implemented in Prolog Examples
Implementation of store term/2 and retrieve term/2
The programs have been transformed manually for these experiments
based on the pointer based representation previously introduced, but
simplified slightly for lists.
For store term/2 and retrieve term/2 we use the following simple
implementation:
store_term([],Index) :- assert(retrieve_term([],Index)).
store_term([X|Xs],Idx) :-
Idx1 is Idx + 1,
assert(retrieve_term(Idx,[X,Idx1])),
store_term(Xs,Idx1).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
21. A workaround implemented in Prolog Examples
Edit Distance
Calculate the minimum number of edits (insertions, deletions and
replacements) to transform on list into another.
a minimal edit-distance algorithm written in Prolog which is
dependent on tabling for any non-trivial problem.
The theoretical best time complexity of edit distance has been proven
to be O(N 2 ).
Measure for various problem sizes.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
22. A workaround implemented in Prolog Examples
Edit distance: Implementation in Prolog.
:- table edit/3. edit([X|Xs],[Y|Ys],Dist) :-
edit([X|Xs],Ys,InsDist),
edit([],[],0). edit(Xs,[Y|Ys],DelDist),
edit(Xs,Ys,TailDist),
edit([],[Y|Ys],Dist) :- (X==Y ->
edit([],Ys,Dist1), Dist = TailDist
Dist is 1 + Dist1. ;
% Minimum of insertion,
edit([X|Xs],[],Dist) :- % deletion or substitution
edit(Xs,[],Dist1), sort([InsDist,DelDist,TailDist],
Dist is 1 + Dist1. [MinDist|_]),
Dist is 1 + MinDist).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
23. A workaround implemented in Prolog Examples
Edit distance, transformed (1).
original version transformed version
edit(XIdx,YIdx,0) :-
edit([],[],0). retrieve_term(XIdx,[]),
retrieve_term(YIdx,[]).
edit(XIdx,YIdx,Dist) :-
edit([],[Y|Ys],Dist) :- retrieve_term(XIdx,[]),
retrieve_term(YIdx,[_,YIdxNext]),
edit([],Ys,Dist1), edit(XIdx,YIdxNext,Dist1),
Dist is 1 + Dist1. Dist is Dist1 + 1.
edit(XIdx,YIdx,Dist) :-
edit([X|Xs],[],Dist) :- retrieve_term(YIdx,[]),
retrieve_term(XIdx,[_,XIdxNext]),
edit(Xs,[],Dist1), edit(XIdxNext,YIdx,Dist1),
Dist is Dist1 + 1.
Dist is 1 + Dist1.
continued on next slide...
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
24. A workaround implemented in Prolog Examples
Edit distance, transformed (2).
original version transformed version
edit([X|Xs],[Y|Ys],Dist) :- edit(XIdx,YIdx,Dist) :-
retrieve_term(XIdx,[X,NextXIdx]),
retrieve_term(YIdx,[Y,NextYIdx]),
edit([X|Xs],Ys,InsDist), edit(XIdx,NextYIdx,InsDist),
edit(Xs,[Y|Ys],DelDist), edit(NextXIdx,YIdx,DelDist),
edit(Xs,Ys,TailDist), edit(NextXIdx,NextYIdx,TailDist),
(X==Y -> (X==Y ->
Dist = TailDist Dist = TailDist
; ;
sort([InsDist,DelDist,TailDist], sort([InsDist,DelDist,TailDist],
[MinDist|_]), [MinDist|_]),
Dist is 1 + MinDist). Dist is 1 + MinDist).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
27. A workaround implemented in Prolog Examples
PRISM
PRISM ( PRogramming In Statistical Modelling )
Extends Prolog (B-Prolog) with special goals representing random
variables (msws).
Semantics: Probabilistic Herbrand models.
Supports various probabilistic inferences.
Relies heavily on tabling for the efficiency of the probabilistic
inferences.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
28. A workaround implemented in Prolog Examples
A Hidden Markov Model in PRISM
values(init,[s0,s1]).
0.1
values(out(_),[a,b]).
values(tr(_),[s0,s1]). 0.8
s0
hmm(L):- 0.3: a
0.5 0.9 s1
msw(init,S), 0.7: b
0.2 0.6: a
hmm(S,L). init
0.4: b
0.5
hmm(_,[]).
hmm(S,[Ob|Y]) :-
msw(out(S),Ob),
msw(tr(S),Next),
hmm(Next,Y).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
29. A workaround implemented in Prolog Examples
Transformed Hidden Markov Model
We only need to consider the recursive predicate, hmm/2.
original version transformed version
hmm(_,[]). hmm(S,ObsPtr):-
retrieve_term(ObsPtr,[]).
hmm(S,[Ob|Y]) :- hmm(S,ObsPtr) :-
msw(out(S),Ob), retrieve_term(ObsPtr,[Ob,Y]),
msw(tr(S),Next), msw(out(S),Ob),
hmm(Next,Y). msw(tr(S),Next),
hmm(Next,Y).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
30. A workaround implemented in Prolog Examples
Hidden Markov Model: Benchmarking results (time)
b) Running time without indexed lookup a) Running time with indexed lookup
140
● ●
0.08
●●●
● ●
●
●
●
120
● ●
● ●
●●
●
Running time (seconds)
Running time (seconds)
●
100
0.06
● ●
●
● ● ●●
● ●
●
● ●
80
●
● ●
●
●
0.04
● ●●
●●
●
60
● ●
● ●
● ●●
●
●
●
40
● ●
● ●
0.02
● ●
●
● ●●
●
● ●
● ●
20
● ●
●
● ●
●
● ●●
●● ●
● ●●
●● ●
● ●
●●●
●●●●●●●●●●
0.00
0
●
0 1000 2000 3000 4000 5000 0 1000 2000 3000 4000 5000
sequence length sequence length
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
31. An automatic program transformation
An automatic program transformation
We introduce an automatic transformation from a tabled program to an
efficient version using our approach.
To support the transformation, the user must declare modes for which
predicate arguments that should be indexed.
table_index_mode(hmm(+))
table_index_mode(hmm(-,+))
Each clause whose head is covered by a table mode declaration is
transformed and all other clauses are left untouched.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
32. An automatic program transformation
Transformation of HMM in PRISM
The transformation moves any term appearing in an indexed position in
the head of a clause into a call to the lookup pattern predicate, which is
added to the body. Variables in such terms are marked lazy when they do
not occur in any non-indexed argument inside the clause.
original program transformed program
hmm(_,[]). hmm(S,ObsPtr):-
lookup_pattern(ObsPtr,[]).
hmm(S,[Ob|Y]) :- hmm(S,ObsPtr) :-
msw(out(S),Ob), lookup_pattern(ObsPtr,[Ob | lazy(Y)]),
msw(tr(S),Next), msw(out(S),Ob),
hmm(Next,Y). msw(tr(S),Next),
hmm(Next,Y).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
33. An automatic program transformation
Each clause whose head predicate is covered by a table mode de
Transformation algorithm
transformed using the procedure outlined in algorithm 1, and all o
are left untouched. The transformation moves any term appearing in
for each clause H:-B in original program do
if table index mode (M) matching H then
for each argument Hi ∈ H, Mi ∈M do
if Mi =’+’ then
Hi ← MarkLazy(Hi , B)
B ← (lookup pattern(Vi , Hi ), B)
Hi ← V i
end
end
where MarkLazy is defined as
MarkLazy(Hi ,B) :
P otentialLazy = variables in all goals G ∈ B
where G has table index mode declaration of Structured Data
Christian Theil Have and Henning Christiansen Efficient Tabling
34. B ← (lookup pattern(Vi , Hi ), B)
An automatic program transformation
Hi ← V i
end
Transformation algorithm: MarkLazy
end
where MarkLazy is defined as
MarkLazy(Hi ,B) :
P otentialLazy = variables in all goals G ∈ B
where G has table index mode declaration
N onLazy = variables in all goals G ∈ B
where G has no table index mode declaration
Lazy = P otentialLazy N onLazy
for each variable V ∈ Hi do
if V ∈ Lazy then
V ← lazy(V )
end
Algorithm 1: Program transformation.
position in the head of a clause into a call to theStructured Data pattern
Christian Theil Have and Henning Christiansen Efficient Tabling of
lookup
35. An automatic program transformation
Conclusions
All Prolog implementations handle tabling of structured data
inefficiently.
We presented a Prolog based program transformation that ensures
O(1) time and space complexity of tabled lookups.
The transformation is data invariant and works with all the existing
tabling systems.
The transformation makes it possible to scale to much larger problem
instances.
Some limitations and problems to be solved:
Only applies to ground input arguments.
Abstract pointers in head of clauses circumvents usual pattern based
indexing (constant time overhead).
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data
36. An automatic program transformation
The road ahead...
Our program transformation should be seen as workaround, until such
optimizations find their way into the tabling systems. We hope that
Prolog implementors will pick up on this and integrate such optimizations
directly in the tabling systems, so that the user does not need to transform
his program, and need not worry about the underlying tabled
representation and its implicit complexity.
Christian Theil Have and Henning Christiansen Efficient Tabling of Structured Data