Bengaluru · Deep Tech · AI Systems · Quantum Algorithms
Vivek Shangari.
I build things that think.
29 years at the intersection of mathematics, computation, and systems design. Built adaptive AI in ANSI Common Lisp in 2010 — before transformers were a paper. Now designing variational quantum circuits, researching quantum-classical hybrid optimisers, and teaching the next generation of engineers to reason at the frontier.
29yr
Continuous R&D
AI since 1998 · Quantum since 2016
↑ Still compounding
18+
Languages mastered
LISP · Python · Rust · Go · C/C++ · Scala · JS · and more
↑ Polyglot since 1998
12K+
Engineers Trained
Algorithms · AI · Quantum · Systems
↑ 68% completion vs 12% MOOC avg
3+
Technical Books
Math · CS Theory · Systems
↑ More in 2027
Adaptive AI Systems
Quantum Algorithms
Variational Circuits
Reinforcement Learning
ANSI Common Lisp
Rust Systems Programming
Algorithm Design
Applied Mathematics
Research interests: Quantum-classical hybrid optimisation · Variational Quantum Eigensolvers (VQE) · Quantum Approximate Optimisation Algorithm (QAOA) · Reinforcement learning for combinatorial search · Symbolic AI and neuro-symbolic integration · Program synthesis in functional languages.
AI Systems Work
Intelligent systems,
not intelligent demos.
From symbolic AI in LISP (1998) to deep learning architectures (2015–) to neuro-symbolic hybrids (2021–). The thread is consistent: systems that generalise, not systems that memorise.
2006 – 2010 · SYMBOLIC AI
Behavioural Signal Modelling — AceNgage
ANSI Common Lisp · Rule-based inference engine
Designed a symbolic inference engine in ANSI Common Lisp that modelled employee behavioural signals across the organisation lifecycle. The system used first-order logic predicates over time-series HR event streams to generate attrition probability distributions. Achieved 78% precision on early-attrition detection at 30-day horizon — with no labelled training data, purely from rule induction over historical sequences.
2010 – 2014 · ADAPTIVE AI
Query Intent Resolution Engine — codeCraft
ANSI Common Lisp · Meta-circular interpreter · Mobile AI
Built a meta-circular query resolution system in ANSI Common Lisp that learned user intent without explicit supervision. The core insight: represent user queries as S-expressions, build a macro-expansion lattice over observed query patterns, and use the lattice as a generative model for unseen inputs. The system handled 94% of enterprise support queries autonomously by month 8 of deployment. This was, effectively, an early form of few-shot in-context learning — four years before the term existed in the literature.
2014 – 2018 · DEEP LEARNING
Neural Curriculum Architecture — Ace Hacker
Python · TensorFlow · Sequence modelling
Designed a sequence-to-sequence model that maps learner interaction traces to predicted knowledge gaps. Used LSTM-based knowledge tracing (inspired by Deep Knowledge Tracing, Piech et al. 2015) with modifications for multi-concept dependency graphs. The model personalises content sequencing per learner in real time. Completion rate lifted from 31% to 68% within two curriculum cycles of deployment.
2018 – 2021 · REINFORCEMENT LEARNING
RL-Driven Pedagogy Engine
Python · Ray RLlib · Multi-armed bandit variants
Framed adaptive curriculum sequencing as a contextual multi-armed bandit problem. State space: learner's embedded knowledge vector (from the DKT model above). Action space: next learning unit from a DAG of ~4,000 nodes. Reward signal: downstream assessment performance at 72-hour horizon. Implemented Thompson Sampling with a neural reward model. Beats the greedy curriculum baseline by 22% on long-horizon learning outcomes across A/B tested cohorts of 3,400+ learners.
2021 – 2024 · NEURO-SYMBOLIC
Neuro-Symbolic Concept Verifier
Python · JAX · Z3 SMT solver · LLM integration
Researching a hybrid architecture where an LLM generates solution candidates for algorithm problems and a symbolic verifier (Z3-based) checks correctness against formal specifications. The LLM provides creative diversity; the verifier eliminates hallucination. The pipeline achieves 91% correct-on-first-verified-attempt on a benchmark of 800 competitive programming problems, versus 61% for the LLM alone. Presented internally at Ace Hacker research days; manuscript in preparation.
2024 – PRESENT · LLM SYSTEMS
Structured Reasoning over Code Execution Traces
Python · Rust · Custom instrumentation
Investigating whether fine-tuning small language models (7B–13B parameter range) on execution traces — rather than source code text — produces better debugging and refactoring capabilities. Early results on a held-out set of 1,200 Rust programs suggest trace-trained models localise bugs 2.3× faster than text-trained baselines. Using Rust's borrow checker output as a structured signal for trace annotation.
Technical position: The most important unsolved problem in applied AI is not scale — it is systematic generalisation. Current transformer architectures are sophisticated interpolators over their training distribution. Building systems that reason reliably outside that distribution requires integrating symbolic structure. This is where the next decade of interesting work lives.
Quantum Computing
Quantum algorithms
as engineering tools.
Active since 2016. Not as a spectator — as a practitioner who writes circuits, runs simulations, and cares about the gap between quantum advantage claims and actual classical hardness. Using Qiskit, PennyLane, and custom circuit simulators written in Rust.
VARIATIONAL ALGORITHMS · 2019–PRESENT
VQE & QAOA Implementation
Implemented Variational Quantum Eigensolver from scratch in PennyLane for small molecular ground-state energy estimation. Extended to QAOA for MaxCut on graphs up to 18 nodes. Primary interest: the noise resilience of parameterised circuits under realistic depolarising error models. Currently exploring barren plateau mitigation using layer-wise learning rate schedules.
PennyLaneQiskitMaxCut
QUANTUM ML · 2021–PRESENT
Quantum Kernel Methods
Investigating quantum kernel functions as a feature map for classical SVM classifiers. The hypothesis: for certain structured datasets (those with quantum-natural symmetries), quantum kernels should outperform classical RBF kernels. Benchmarking on synthetic datasets with known group symmetries. Results so far are sobering — genuine quantum advantage in the kernel regime appears to require problem structure that most practical ML datasets do not have.
Quantum KernelsSVMFeature Maps
QUANTUM SIMULATION · 2022–PRESENT
Custom Circuit Simulator in Rust
Building a statevector simulator in Rust for circuits up to 28 qubits on a single machine, using SIMD-accelerated complex matrix operations and a sparse tensor representation for low-entanglement circuits. Motivation: understanding the implementation at this level is the only reliable way to reason about the complexity claims in the literature. Current throughput: ~10⁷ gate operations/second on an M-class processor.
RustSIMDStatevector
QAOA APPROXIMATION RATIO vs CIRCUIT DEPTH — MAXCUT ON RANDOM 3-REGULAR GRAPHS (n=12)
Simulated results · Depolarising noise p=0.001 · Averaged over 50 random graph instances · Classical optimum = 1.0
Honest assessment: Fault-tolerant quantum computing is 10–15 years away from practical utility for most optimisation problems. NISQ-era algorithms have genuine theoretical interest but limited practical advantage over well-tuned classical heuristics. The productive question is not "when will quantum beat classical?" but "which problem instances have provable quantum hardness that we actually care about solving?"
Algorithms & Mathematics
The substrate
beneath everything.
Algorithm design is not a skill — it is a way of seeing. Every AI system, every quantum circuit, every distributed architecture is, at its core, an algorithm. The mathematics is not decoration. It is the load-bearing structure.
Adaptive Attrition Predictor
PROBABILISTIC INFERENCE · AceNgage · 2007
A sequential Bayesian update model over employee event streams. Models attrition probability as a hidden Markov process where observations are HR event types (performance review, leave request, peer feedback sentiment). Transition matrix estimated via EM algorithm on historical data. Outperforms logistic regression baseline by 19 F1-points at 60-day prediction horizon with far less labelled data.
Inference: O(n·k²) per timestep · k = hidden states · n = employees
Query Expansion via S-Expression Lattice
SYMBOLIC AI · codeCraft · 2011
Represents natural language queries as partially-evaluated LISP S-expressions. Builds a subsumption lattice over the query space using anti-unification. Novel queries are resolved by finding the most-specific generalisation in the lattice and pattern-matching against stored solution templates. This is essentially a typed version of case-based reasoning with a LISP runtime as the execution substrate. Zero shot at deployment; improves with each new resolved query.
Lattice construction: O(n² · |Q|) · Query resolution: O(log n · d) · d = query depth
Deep Knowledge Tracing with Concept DAGs
SEQUENCE MODELLING · Ace Hacker · 2016
Extension of standard DKT (Piech 2015) that incorporates prerequisite structure between knowledge components as a directed graph constraint. The LSTM hidden state is projected through the adjacency matrix of the concept DAG before producing knowledge estimates, enforcing that mastery of advanced concepts cannot exceed the minimum mastery of their prerequisites. Reduces knowledge state inconsistencies by 67% vs. unconstrained DKT on our learner dataset.
Training: O(T·d²·|E|) per batch · T = sequence length · |E| = concept graph edges
Rust Borrow-Aware Bug Localiser
PROGRAM ANALYSIS · Research · 2024
A static analysis pass over Rust MIR (Mid-level Intermediate Representation) that constructs a borrow graph and identifies ownership violation patterns. Uses a dataflow analysis framework to propagate liveness and borrow constraints backwards from error sites. The output is a ranked list of candidate bug sites with explanation traces. When combined with an LLM fix-suggester, achieves 2.3× faster bug localisation than unassisted LLM prompting on a benchmark of 1,200 programs.
Dataflow analysis: O(|CFG| · |vars|) · Borrow graph construction: O(|MIR| · α(n))
ALGORITHM DOMAINS — YEARS OF ACTIVE WORK
MATHEMATICAL FOUNDATIONS — DEPTH SELF-ASSESSMENT
Systems Built
Production systems,
not prototypes.
Every algorithm above ran in production, at scale, serving real users. The gap between a working prototype and a production system is where most research dies. These systems survived that gap.
| System |
Language / Stack |
Scale at Peak |
Key Technical Achievement |
| Symbolic HR Inference Engine |
ANSI Common Lisp |
12 enterprise orgs · ~18K employees |
78% attrition precision · zero labelled training data |
| Meta-circular Query Resolver |
ANSI Common Lisp · SBCL |
4 Fortune 500 clients · ~2M queries/month |
94% autonomous resolution rate · p50 latency 12ms |
| DKT-DAG Knowledge Tracer |
Python · TensorFlow · PostgreSQL |
12,000+ active learners · 4,000 concept nodes |
68% completion rate · 2.2× lift over static curriculum |
| RL Curriculum Sequencer |
Python · Ray RLlib · Redis |
3,400+ learners · real-time action selection |
22% downstream assessment improvement vs greedy |
| Neuro-Symbolic Code Verifier |
Python · JAX · Z3 · GPT-4-turbo |
800-problem benchmark · research prototype |
91% correct-on-first-verified vs 61% LLM-only |
| Quantum Circuit Simulator |
Rust · SIMD intrinsics |
28-qubit max · single machine |
10⁷ gate-ops/sec · sparse tensor for low entanglement |
LANGUAGE DEPTH — YEARS OF PRODUCTION USE
Engineering principle: A system that works at 100 users and fails at 10,000 was never a system — it was a demo with a deadline. Every design decision above was made with the failure modes of the production environment as the primary constraint, not the happy path.
COMMON LISP — 18 YEARS
Why LISP still matters
ANSI Common Lisp is not nostalgia — it is the only mainstream language where the program and the data share the same representation. This makes meta-circular evaluation, macro-based DSL construction, and runtime program modification not just possible but natural. The codeCraft query resolver could not have been built as cleanly in any other language available at the time.
RUST — 10 YEARS
Rust as a research tool
The borrow checker is not a restriction — it is a theorem prover for memory safety embedded in the type system. For the quantum simulator and the borrow-aware bug localiser, Rust's zero-cost abstractions and SIMD support are essential. The ownership model also maps cleanly onto quantum register semantics: a qubit, like a move-only value, cannot be cloned without explicit measurement.
PYTHON ECOSYSTEM — 18 YEARS
Python as the lingua franca
JAX over PyTorch for research: functional transformations (jit, grad, vmap) compose cleanly with quantum circuit autodiff. The DKT and RL systems use TF/RLlib respectively because they were built when those were the right trade-offs. For new ML research work, JAX + Flax is the current default. Python is the glue; the real computation happens in XLA, CUDA, or the Rust layer beneath.
Career Timeline
29 years.
Each one deliberate.
The career reads as a business story from the outside. From the inside, it has always been a research story — each role provided a different constraint set, a different scale, a different failure mode. The companies were the lab. The problems were the experiments.
2014 – PRESENT · FOUNDER
Ace Hacker — Founder & CEO
acehacker.com · EdTech · AI Curriculum Systems
Research focus: learning science, knowledge tracing, adaptive curriculum systems, neuro-symbolic education AI. Built DKT-DAG, RL sequencer, and the neuro-symbolic verifier here. The 12,000 learners are simultaneously users and a longitudinal dataset for learning science research. 68% completion rate is a research result, not just a business metric.
2010 – 2014 · FOUNDER
codeCraft — Founder & CEO
Mobile AI · ANSI Common Lisp · Fortune 100 acqui-hire
Research focus: symbolic AI, meta-circular interpretation, query intent modelling without supervision. The S-expression lattice resolver was the core IP. Built on SBCL with a custom MOP extension for runtime query-class generation. Acqui-hired Q3 2014 — the Fortune 100 acquirer's AI team cited the lattice architecture as a novel prior art contribution in the acquisition diligence.
2010 – 2014 · FOUNDER
Vichaar Foundation — Founder & Trustee
GovTech · Civic Technology · Not-for-profit
Applied graph algorithms and network analysis to electoral data to detect anomalous precinct-level patterns. Built a constituency-level information diffusion model using a modified SIR (Susceptible-Infected-Recovered) framework adapted for political information spread. The model correctly predicted 14 of 18 contested constituency outcomes in a test election cycle. Wound down due to regulatory constraints, not technical failure.
2006 – 2010 · CO-FOUNDER & CTO
AceNgage — Co-founder & CTO
HR Analytics · Behavioural Modelling · MBO exit
Research focus: probabilistic inference over HR event streams, hidden Markov models for employee lifecycle, Bayesian attrition prediction. The inference engine was written in ANSI Common Lisp and ran on SBCL. This was where the symbolic AI work began in earnest — the system had to be explainable to HR practitioners, which forced a rule-based representation rather than a black-box model.
2004 – 2006 · PROGRAM MANAGER
ICICI oneSource — Program Manager
Global Financial Services · Process systems
First encounter with queueing theory in production: modelled BPO service delivery as an M/M/c queue and used Little's Law to right-size team capacity. Built a discrete-event simulation in Excel VBA (pre-Python era) to forecast SLA breach probability under variable arrival rates. The simulation was accurate to within 4% of actual SLA outcomes over 18 months of production use.
1998 – 2004 · PROGRAMMER → LEAD
ICS & Andale — Programmer → Lead Programmer
Systems development · Lisp · C · C++ · Java · Perl
Where the fundamentals were built — not read about, but debugged under deadline. Implemented B-tree variants, hash table collision resolution strategies, and a custom memory allocator in C during the ICS years. Also, built the first version of a distributed caching layer in Java, predating memcached. The cache invalidation strategy (time-to-live plus event-triggered invalidation) is still the one I reach for first.
| Organisation |
Timeline (1998 – Present) |
Duration |
What I Teach
Teaching as
the deepest proof.
The real test of understanding is not whether you can pass an exam. It is whether you can make someone else understand it — including someone who thinks they can't. 12,000+ engineers trained across the following domains. These are not survey courses.
ALGORITHMS & DATA STRUCTURES
The Complete Picture
Not a language-specific course. The topic is mathematical objects — graphs, trees, lattices, sequences — and the algorithms that operate on them. Covers amortised analysis, randomised algorithms, approximation algorithms, and NP-hardness reductions. The course ends with the P vs NP question as an open problem, which is where every serious algorithms course should end.
O-notationGraph TheoryNP-CompletenessRandomised Algos
MACHINE LEARNING THEORY
From PAC Learning to Transformers
Starts with Valiant's PAC learning framework — because understanding what it means for a model to "learn" requires a formal definition. Covers VC dimension, bias-variance, kernel methods, and then deep learning as a special case of function approximation. The attention mechanism is derived from first principles as a differentiable associative memory retrieval operation.
PAC LearningVC DimensionAttention Mechanism
QUANTUM COMPUTING
From Qubits to Algorithms
The course assumes linear algebra and complex numbers — nothing else. Derives the qubit representation, the Bloch sphere, universal gate sets, and quantum parallelism from first principles. Then: Deutsch-Jozsa, Grover's search (with a proof of quadratic speedup), Shor's factoring algorithm (with a proof of the period-finding reduction), and VQE as a practical NISQ algorithm. Implemented in Qiskit throughout.
GroverShorVQEQiskit
FUNCTIONAL PROGRAMMING
LISP, Haskell, Rust
Functional programming is not a syntax preference — it is a mathematical discipline. The course starts with λ-calculus, derives Church encoding of data types, proves the Y-combinator, and then moves to practical LISP, Haskell type classes, and finally Rust's trait system as a statically-typed functional language. The goal: think in functions, not in loops.
λ-CalculusLISPHaskellRust
APPLIED MATHEMATICS
The Engineer's Mathematics
Linear algebra (with a focus on eigendecomposition and SVD as the engine behind PCA, recommender systems, and attention), multivariate calculus (the chain rule as backpropagation), probability theory (Bayes' theorem as inference, not just a formula), and information theory (entropy, KL divergence, mutual information as the language of learning algorithms). No theorem is stated without an application; no application is given without the underlying theorem.
Linear AlgebraProbabilityInformation Theory
SYSTEMS PROGRAMMING
Rust, C, and the Machine
Memory layout, cache behaviour, concurrency primitives, lock-free data structures, and systems design under adversarial conditions. Taught through Rust because Rust's type system makes the invisible visible: lifetimes make aliasing explicit, Send/Sync make thread-safety explicit, unsafe blocks make hardware assumptions explicit. C is taught as the substrate — to understand what Rust is abstracting away and why those abstractions have costs.
RustCLock-freeMemory Models
Pedagogical philosophy: The REST loop — Research the frontier first, Experiment with implementations, Study the theoretical foundations, Teach it until you can make it inevitable. A concept is not understood until it can be taught without notes. Every course above has been taught at least 40 times in that loop.
Published Works
Writing that
respects the reader's intelligence.
Three books at the intersection of technical rigour and genuine readability. The thesis: hard ideas do not need to be made easier — they need to be made clearer. There is a difference. The equations are real. The algorithms run. The jokes are load-bearing.
COMPUTATIONAL NEUROSCIENCE · PROBABILITY · COGNITIVE SCIENCE
The Mathematics of Anxiety
Models the anxious brain as a Bayesian inference engine running on corrupted priors. Covers the predictive processing framework (Friston's Free Energy Principle), the halting problem as a formal model of rumination, and the mathematics of exposure therapy as a posterior update process. Every equation is real. Every Python snippet runs. The jokes are there because the alternative is unbearable.
Read online →
PHYSICS · INFORMATION THEORY · PHILOSOPHY OF SCIENCE
Calculus of Chaos
A rigorous and unreasonably funny guide to the mathematical structures underlying thermodynamics, information theory, and quantum mechanics — written for the reader who wants the equations and the punchlines simultaneously. Covers entropy (Boltzmann, Shannon, von Neumann), the measurement problem, and the many-worlds interpretation's mathematical basis.
Releasing soon
RUST SYSTEMS PROGRAMMING · FICTION · COMPUTER SCIENCE
Diabolical Code
A spy thriller in which the narrative mechanism is a complete Rust systems programming course. The story requires the reader to implement memory-safe concurrency, lock-free data structures, and an encrypted message protocol — not as exercises, but as plot devices. By the end, the reader has written a real Rust program and survived an assassination attempt. Not necessarily in that order.
Releasing in Dec 2026
IN PROGRESS · 2026–2027
A fourth book on quantum algorithm design for classical computer scientists. Several more titles on type theory, formal verification, and the mathematics of reinforcement learning planned for 2027.
Collaborate
Let's work on
something hard.
The most productive conversations I have had were with people who disagreed with my technical positions and could say precisely why. If you have a counterargument, a collaboration proposal, or a problem that is genuinely difficult — I am interested.
