prodigy-ppl 0.1.0__py3-none-any.whl

prodigy/analysis/__init__.py

@@ -0,0 +1,36 @@
+"""
+================
+Forward Analysis
+================
+
+The semantics transformation of the forwards analysis is mainly specified in the instruction handlers. They provide
+the actual semantics on a generic level without knowing any specific encoding of a probability distribution.
+
+The Semantics
+#############
+
+The semantics of a probabilistic program is defined as a distribution transformer. Each individual program instruction
+is handled via a dedicated instruction handler. These handlers describe on a generic level, how the input distribution
+is changed after executing the program instruction. This is oftentimes not computable, i.e., when the input distribution
+has infinite support, or in case of while-loop instructions.
+
+Distribution
+############
+
+Distributions are the core objects to transform by a probabilistic program. This class specifies a generic interface
+with desired convenience methods needed, in order to abstract away from an actual distribution encoding.
+In fact, we deliver two types of distribution backends:
+
+#. A `sympy` implementation of generating functions
+#. A `GiNaC` C++ implementation shipped as a `pybind11` module.
+
+.. automodule:: prodigy.distribution
+
+Analysis Configuration
+######################
+
+Sometimes, intermediate steps of the computation are desired. This and more configurations can be setup in a
+`ForwardAnalysisConfig` object. Here also different backend Engines can be chosen.
+
+.. automodule:: prodigy.analysis.config
+"""

prodigy/analysis/ai_candidates.py

@@ -0,0 +1,227 @@
+"""
+Loop invariants proposed by a language model and checked by Prodigy.
+
+The model only proposes candidates. Every candidate goes through the same exact check as an
+invariant typed in by hand (strategies ``evt_invariant`` and ``evt_subinvariant``), so a wrong
+answer makes an attempt fail but never makes a result unsound. When a candidate is rejected, the
+next request tells the model why (e.g. Φ(I) − I), so it can correct itself.
+
+Answers are untrusted input. Before any computer algebra system sees a candidate (SymPy's parser
+evaluates Python code), it must consist of numbers, the program's variables and parameters,
+``+ - * / ^``, parentheses, ``sqrt`` and ``exp``, and parse as a pGCL expression.
+
+Configuration, read from the environment of ``prodigy`` (it never reaches the browser):
+
+* ``ANTHROPIC_API_KEY``: Claude API, model ``PRODIGY_AI_MODEL`` (default ``claude-sonnet-5-5``);
+  ``ANTHROPIC_WORKSPACE_ID`` for a key that is not scoped to a workspace.
+* ``OPENAI_API_KEY`` and/or ``PRODIGY_AI_BASE_URL`` with ``PRODIGY_AI_MODEL``: an OpenAI-compatible
+  chat-completions API, e.g. ``http://localhost:11434/v1`` for a local model served by Ollama.
+* ``PRODIGY_AI_PROVIDER`` (``anthropic`` or ``openai``) chooses if both are configured;
+  ``PRODIGY_AI_TIMEOUT``: seconds per request (default 120).
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence, Tuple
+
+from prodigy.pgcl.parser import parse_expr
+
+DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5-5"
+ANTHROPIC_URL = "https://api.anthropic.com/v1/messages"
+ANTHROPIC_VERSION = "2026-10-21"
+FUNCTIONS = frozenset({"sqrt", "exp"})
+FORMS = ("evt_invariant", "evt_subinvariant")
+
+
+class AIConfigurationError(Exception):
+    """No language model is configured, or its configuration is incomplete."""
+
+
+class AIRequestError(Exception):
+    """The request to the language model failed."""
+
+
+class CandidateError(ValueError):
+    """An answer contains no admissible candidate."""
+
+
+@dataclass(frozen=True)
+class Provider:
+    name: str
+    model: str
+    ask: Callable[[str, str], str]
+    """(system prompt, user prompt) -> text of the answer"""
+    diagnostics: Dict[str, Any] = field(default_factory=dict)
+    """Why the last answer ended (``stop_reason``) and the kinds of its content blocks."""
+
+
+def _post(url: str, headers: Dict[str, str], body: Dict[str, Any], timeout: float) -> Dict[str, Any]:
+    request = urllib.request.Request(url, data=json.dumps(body).encode("utf-8"), method="POST",
+                                     headers={"content-type": "application/json", **headers})
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="replace")[:500]
+        raise AIRequestError(f"{url} answered {exc.code}: {detail}") from exc
+    except (urllib.error.URLError, OSError) as exc:
+        raise AIRequestError(f"{url} could not be reached: {exc}") from exc
+
+
+def get_provider(env: Optional[Mapping[str, str]] = None) -> Provider:
+    """The configured language model (see the module documentation)."""
+    env = os.environ if env is None else env
+    choice = env.get("PRODIGY_AI_PROVIDER", "").strip().lower()
+    if not choice:
+        if env.get("ANTHROPIC_API_KEY"):
+            choice = "anthropic"
+        elif env.get("OPENAI_API_KEY") or env.get("PRODIGY_AI_BASE_URL"):
+            choice = "openai"
+    timeout = float(env.get("PRODIGY_AI_TIMEOUT") or 120)
+    if choice == "anthropic":
+        return _anthropic(env, timeout)
+    if choice == "openai":
+        return _openai(env, timeout)
+    if choice:
+        raise AIConfigurationError(f"Unknown PRODIGY_AI_PROVIDER {choice!r} (anthropic or openai).")
+    raise AIConfigurationError(
+        "No language model is configured. Set ANTHROPIC_API_KEY (Claude API), or OPENAI_API_KEY or "
+        "PRODIGY_AI_BASE_URL together with PRODIGY_AI_MODEL (OpenAI-compatible API, e.g. a local model) "
+        "in the environment of prodigy, and start it again.")
+
+
+def _anthropic(env: Mapping[str, str], timeout: float) -> Provider:
+    key = env.get("ANTHROPIC_API_KEY")
+    if not key:
+        raise AIConfigurationError("PRODIGY_AI_PROVIDER=anthropic needs ANTHROPIC_API_KEY.")
+    model = env.get("PRODIGY_AI_MODEL") or DEFAULT_ANTHROPIC_MODEL
+    headers = {"authorization": f"Bearer {key}", "anthropic-version": ANTHROPIC_VERSION}
+    if env.get("ANTHROPIC_WORKSPACE_ID"):
+        headers["anthropic-workspace-id"] = env["ANTHROPIC_WORKSPACE_ID"]
+
+    diagnostics: Dict[str, Any] = {}
+
+    def ask(system: str, user: str) -> str:
+        # room for the model's reasoning; only the tokens used are billed
+        reply = _post(ANTHROPIC_URL, headers, {"model": model, "max_tokens": 16000, "system": system,
+                                               "messages": [{"role": "user", "content": user}]}, timeout)
+        blocks = reply.get("content") or []
+        diagnostics.clear()
+        diagnostics.update(stop_reason=reply.get("stop_reason"), content=[b.get("type") for b in blocks])
+        return "".join(block.get("text", "") for block in blocks if block.get("type") == "text")
+
+    return Provider("anthropic", model, ask, diagnostics)
+
+
+def _openai(env: Mapping[str, str], timeout: float) -> Provider:
+    model = env.get("PRODIGY_AI_MODEL")
+    if not model:
+        raise AIConfigurationError("An OpenAI-compatible API needs PRODIGY_AI_MODEL (the name of the model).")
+    url = (env.get("PRODIGY_AI_BASE_URL") or "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
+    headers = {"authorization": f"Bearer {env['OPENAI_API_KEY']}"} if env.get("OPENAI_API_KEY") else {}
+
+    diagnostics: Dict[str, Any] = {}
+
+    def ask(system: str, user: str) -> str:
+        reply = _post(url, headers, {"model": model, "messages": [{"role": "system", "content": system},
+                                                                   {"role": "user", "content": user}]}, timeout)
+        try:
+            choice = reply["choices"][0]
+            diagnostics.clear()
+            diagnostics.update(stop_reason=choice.get("finish_reason"))
+            return choice["message"]["content"] or ""
+        except (KeyError, IndexError, TypeError, AttributeError) as exc:
+            raise AIRequestError(f"{url}: unexpected answer {str(reply)[:300]}") from exc
+
+    return Provider("openai", model, ask, diagnostics)
+
+
+# ---------------------------------------------------------------------------------------
+# Prompts and answers
+# ---------------------------------------------------------------------------------------
+
+SYSTEM_PROMPT = (
+    "You help the verifier Prodigy analyse probabilistic programs with loops. Prodigy represents a "
+    "distribution over program states by its probability generating function (PGF) in the program "
+    "variables: the coefficient of x^i*c^j is the probability of the state x = i, c = j. You propose a "
+    "generating function; Prodigy checks it exactly and rejects it if it is wrong. Your candidate is a "
+    "single closed-form expression in the program variables and parameters, using numbers, + - * / ^, "
+    "parentheses, sqrt and exp. Keep any reasoning short and end your answer with the line\n"
+    "ANSWER: <expression>\n"
+    "If you cannot find a candidate, end with the line ANSWER: none")
+
+_TASKS = {
+    "evt_invariant": (
+        "Find the generating function I of the expected visiting times at the head of the loop: the least "
+        "solution of I = G + B(<I>_guard), where G is the PGF entering the loop, <F>_guard keeps the terms "
+        "of F whose states satisfy the guard, and B is the PGF transformer of one execution of the loop "
+        "body. Then <I>_(not guard) is the output distribution of the loop. I must have non-negative "
+        "coefficients; Prodigy accepts it as exact only if I(1, ..., 1) is finite."),
+    "evt_subinvariant": (
+        "Find an occupation sub-invariant nu: a generating function with non-negative coefficients and "
+        "finite mass nu(1, ..., 1) such that nu <= G + B(<nu>_guard) coefficient-wise, where G is the PGF "
+        "entering the loop, <F>_guard keeps the terms of F whose states satisfy the guard, and B is the "
+        "PGF transformer of one execution of the loop body. Then <nu>_(not guard) is a lower bound on the "
+        "output distribution. The expected visiting times are the best choice if their mass is finite; "
+        "otherwise choose a smaller nu with finite mass."),
+}
+
+_EXAMPLE = ("Example: for `nat x; nat c; x := 1; while (x = 1) { {x := 0} [1/2] {c := c + 1} }` the loop "
+            "is entered with G = x, and its expected visiting times are (x + 1/2)/(1 - c/2).")
+
+
+def prompt(form: str, program: str, loop: str, variables: Sequence[str], parameters: Sequence[str],
+           entering: str, rejected: Sequence[Tuple[str, str]]) -> str:
+    """The request for a candidate of kind ``form`` (see :data:`FORMS`) for ``loop``."""
+    parts = [f"Program:\n{program}", f"The loop:\n{loop}",
+             f"Program variables: {', '.join(variables)}",
+             f"Parameters (unknown constants): {', '.join(parameters) if parameters else 'none'}",
+             f"G, the PGF entering the loop: {entering}", _TASKS[form], _EXAMPLE]
+    if rejected:
+        parts.append("Prodigy rejected these candidates; do not propose them again:\n"
+                     + "\n".join(f"- {candidate}: {reason}" for candidate, reason in rejected))
+    return "\n\n".join(parts)
+
+
+_FENCE = re.compile(r"```[A-Za-z]*\n?(.*?)```", re.S)
+_ANSWER = re.compile(r"^[\s*_#>]*ANSWER[\s*_]*:[\s*_`$]*(.*?)[\s*_`$]*$", re.I | re.M)
+_PREFIX = re.compile(r"^(?:[A-Za-z_]\w*\s*(?:\([^)]*\))?\s*=\s*)+")
+_ALLOWED = re.compile(r"[0-9A-Za-z_+\-*/^().\s]+")
+_IDENTIFIER = re.compile(r"[A-Za-z_]\w*")
+
+
+def candidate_from_answer(answer: str, names: Sequence[str]) -> str:
+    """The candidate in a model's answer: its last ``ANSWER:`` line, else the last line of its last
+    code block or of the answer.
+
+    Raises :class:`CandidateError` unless it is an expression over ``names``, numbers,
+    ``+ - * / ^``, parentheses, ``sqrt`` and ``exp`` that parses as a pGCL expression."""
+    marked = _ANSWER.findall(answer)
+    if marked:
+        line = marked[-1].strip()
+        if line.lower().strip(".") in ("none", "unknown", ""):
+            raise CandidateError("The model found no candidate (ANSWER: none).")
+    else:
+        blocks = _FENCE.findall(answer)
+        lines = [line.strip() for line in (blocks[-1] if blocks else answer).splitlines() if line.strip()]
+        if not lines:
+            raise CandidateError("The answer contains no text.")
+        line = lines[-1]
+    candidate = _PREFIX.sub("", line.strip("`$ ")).rstrip(".;").strip().replace("**", "^")
+    if not _ALLOWED.fullmatch(candidate):
+        raise CandidateError(f"{candidate!r} contains characters other than numbers, variables, "
+                             "+ - * / ^ and parentheses.")
+    unknown = sorted(set(_IDENTIFIER.findall(candidate)) - set(names) - FUNCTIONS)
+    if unknown:
+        raise CandidateError(f"{candidate!r} uses {', '.join(unknown)}, which are neither program "
+                             "variables nor parameters.")
+    try:
+        parse_expr(candidate)
+    except Exception as exc:  # pylint: disable=broad-except  # lark raises several error types
+        raise CandidateError(f"{candidate!r} is not a well-formed expression: {exc}") from exc
+    return candidate

prodigy/analysis/analyzer.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import functools
+import logging
+from typing import Callable, Optional, Union, Sequence, get_args
+
+from prodigy.pgcl import Program, Instr, SkipInstr, AbortInstr, WhileInstr, LoopInstr, QueryInstr, Query, \
+    ObserveInstr, ChoiceInstr, AsgnInstr, IfInstr
+
+from prodigy.analysis.config import ForwardAnalysisConfig
+from prodigy.analysis.exceptions import ObserveZeroEventError
+from prodigy.analysis.instructionhandler.assignment_handler import AssignmentHandler
+from prodigy.analysis.instructionhandler.ite_handler import ITEHandler
+from prodigy.analysis.instructionhandler.loop_handler import LoopHandler
+from prodigy.analysis.instructionhandler.observe_handler import ObserveHandler
+from prodigy.analysis.instructionhandler.probchoice_handler import PChoiceHandler
+from prodigy.analysis.instructionhandler.program_info import ProgramInfo
+from prodigy.analysis.instructionhandler.query_handler import QueryHandler
+from prodigy.analysis.instructionhandler.queryblock_handler import QueryBlockHandler
+from prodigy.analysis.instructionhandler.while_handler import WhileHandler
+from prodigy.analysis.session import current_session
+from prodigy.distribution import Distribution
+from prodigy.util.color import Style
+from prodigy.util.logger import log_setup
+
+logger = log_setup(str(__name__).rsplit(".", maxsplit=1)[-1], logging.DEBUG)
+
+
+def condition_distribution(
+        dist: Distribution, error_prob: Distribution,
+        config: ForwardAnalysisConfig) -> tuple[Distribution, Distribution]:
+    # lets the session rescale the residual mass of approximated loops
+    current_session().on_normalize(error_prob)
+    one = config.factory.one(*error_prob.get_variables())
+    zero = one * "0"
+    if dist == zero and error_prob == one:
+        raise ObserveZeroEventError(
+            "Undefined semantics: Probability of observing a valid run is 0.")
+    result = dist / (one - error_prob)
+    return result, error_prob
+
+
+def compute_discrete_distribution(
+        program: Program | ProgramInfo, dist: Distribution,
+        config: ForwardAnalysisConfig,
+        step_callback: Optional[Callable[[Instr, Distribution, Distribution], None]] = None
+) -> tuple[Distribution, Distribution]:
+    """
+    Computes the output distribution of ``program`` for the input ``dist``.
+
+    :param step_callback: if given, called with (instruction, distribution, error_prob) after each
+        top-level instruction.
+    """
+    logger.debug("Compute the distribution for\n%s\nand distribution %s", str(program), dist)
+
+    # Inject the context from the parsed program into the initial distribution.
+    prog_info = program if isinstance(program,
+                                      ProgramInfo) else ProgramInfo(program)
+    variables = set(prog_info.variables.keys()).union(dist.get_variables())
+    parameters = set(prog_info.parameters.keys()).union(dist.get_parameters())
+    initial_dist = dist.set_variables(*variables).set_parameters(*parameters)
+    error_prob = config.factory.one(*variables) * 0
+    if step_callback is None:
+        dist, error_prob = compute_semantics(prog_info.instructions,
+                                             prog_info, initial_dist,
+                                             error_prob, config)
+    else:
+        dist = initial_dist
+        for instr in prog_info.instructions:
+            dist, error_prob = compute_semantics([instr], prog_info, dist, error_prob, config)
+            step_callback(instr, dist, error_prob)
+    if config.normalize:
+        dist, error_prob = condition_distribution(dist, error_prob, config)
+    return dist, error_prob
+
+
+def compute_semantics(
+        instruction: Union[Instr, Sequence[Instr]],
+        prog_info: ProgramInfo,
+        distribution: Distribution,
+        error_prob: Distribution,
+        config=ForwardAnalysisConfig()
+) -> tuple[Distribution, Distribution]:
+    def _show_steps(inp: tuple[Distribution, Distribution],
+                    instr: Instr) -> tuple[Distribution, Distribution]:
+        dist, error_prob = inp
+        res, error_prob = compute_semantics(instr, prog_info, dist,
+                                            error_prob, config)
+        if isinstance(instr, (WhileInstr, IfInstr, LoopInstr)):
+            print("\n")
+        output = f"\n{Style.BLUE}Instruction:{Style.RESET} {instr}\t {Style.GREEN}Result:{Style.RESET} {res}"
+        print(output, prog_info.so_vars)
+        if config.step_wise:
+            current_session().provider.next_step()
+        return res, error_prob
+
+    def _dont_show_steps(
+            inp: tuple[Distribution, Distribution],
+            instr: Instr) -> tuple[Distribution, Distribution]:
+        dist, error_prob = inp
+        return compute_semantics(instr, prog_info, dist, error_prob,
+                                 config)
+
+    if not isinstance(instruction, list):
+        current_session().on_instruction(instruction)
+
+    if isinstance(instruction, list):
+        func = _show_steps if config.show_intermediate_steps else _dont_show_steps
+        return functools.reduce(func, instruction,
+                                (distribution, error_prob))
+
+    elif isinstance(instruction, SkipInstr):
+        return distribution, error_prob
+
+    elif isinstance(instruction, AbortInstr):
+        return distribution.factory().undefined(
+            *distribution.get_variables()), error_prob
+
+    elif isinstance(instruction, WhileInstr):
+        logger.info("\n%s gets handled", instruction)
+        return WhileHandler.compute(instruction, prog_info, distribution,
+                                    error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, IfInstr):
+        return ITEHandler.compute(instruction, prog_info, distribution,
+                                  error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, AsgnInstr):
+        return AssignmentHandler.compute(instruction, prog_info,
+                                         distribution, error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, ChoiceInstr):
+        return PChoiceHandler.compute(instruction, prog_info, distribution,
+                                      error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, ObserveInstr):
+        logger.info("%s gets handled", instruction)
+        return ObserveHandler.compute(instruction, prog_info, distribution,
+                                      error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, get_args(Query)):
+        logger.info("%s gets handled", instruction)
+        if config.normalize:
+            distribution, error_prob = condition_distribution(
+                distribution, error_prob,
+                config)  # evaluate queries on conditioned distribution
+            error_prob *= "0"
+        return QueryHandler.compute(instruction, prog_info, distribution,
+                                    error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, LoopInstr):
+        logger.info("%s gets handled", instruction)
+        return LoopHandler.compute(instruction, prog_info, distribution,
+                                   error_prob, config, compute_semantics)
+
+    elif isinstance(instruction, QueryInstr):
+        logger.info("entering query block")
+        return QueryBlockHandler.compute(instruction, prog_info,
+                                         distribution, error_prob, config, compute_semantics)
+
+    raise TypeError("illegal instruction")

prodigy/analysis/config.py

@@ -0,0 +1,98 @@
+"""
+-----------------------
+Forward Analysis Config
+-----------------------
+"""
+from enum import Enum, auto
+from typing import Type
+
+import attr
+
+from prodigy.analysis.optimization import Optimizer
+from prodigy.analysis.optimization.gf_optimizer import GFOptimizer
+from prodigy.distribution.generating_function import (GeneratingFunction,
+                                                      SympyPGF)
+from prodigy.distribution.symengine_distribution import SymenginePGF
+from .evtinvariants.heuristics.positivity.heuristics_factory import PositivityHeuristics
+from .evtinvariants.heuristics.strategies import SynthesisStrategies
+from .evtinvariants.heuristics.templates.templates_factory import TemplateHeuristics
+from .exceptions import ConfigurationError
+from .solver.solver_type import SolverType
+from ..distribution.distribution import CommonDistributionsFactory
+
+
+@attr.s
+class ForwardAnalysisConfig:
+    """Global configurable options for forward analysis."""
+
+    class Engine(Enum):
+        """
+        This enumeration specifies the type of backend used for distribution encodings and mathematical operations.
+        """
+        SYMPY = auto()
+        GINAC = auto()
+        SYMENGINE = auto()
+
+    show_intermediate_steps: bool = attr.ib(default=False)
+    """Enables the printing of results after each instruction."""
+
+    step_wise: bool = attr.ib(default=False)
+    """Enables step-by-step computation"""
+
+    use_simplification: bool = attr.ib(default=False)
+    """Enables simplification heuristics for expressions."""
+
+    use_latex: bool = attr.ib(default=False)
+    """Toggle to print LaTeX-Code instead of ASCII expressions."""
+
+    engine: Engine = attr.ib(default=Engine.SYMPY)
+    """Selects the distribution backend."""
+
+    normalize: bool = attr.ib(default=True)
+    """Switch to compute the normalized distribution"""
+
+    strategy: SynthesisStrategies = attr.ib(default=SynthesisStrategies.DEFAULT)
+    """The Strategy for dealing with synthesis."""
+
+    templ_heuristic: TemplateHeuristics = attr.ib(default=TemplateHeuristics.DEFAULT)
+    """ The heuristics to use for template genesis"""
+
+    positivity_heuristic: PositivityHeuristics = attr.ib(default=PositivityHeuristics.DEFAULT)
+    """ The heuristics to validate positivity"""
+
+    solver_type: SolverType = attr.ib(default=SolverType.SYMPY)
+    """The solver to use for equation systems."""
+
+    show_all_invs: bool = attr.ib(default=False)
+    """Toggels printing of spurious invariants"""
+
+    @property
+    def optimizer(self) -> Type[Optimizer]:
+        if self.engine == ForwardAnalysisConfig.Engine.SYMPY:
+            return GFOptimizer
+        else:
+            raise ConfigurationError(
+                "The configured engine does not implement an optimizer.")
+
+    @property
+    def factory(self) -> Type[CommonDistributionsFactory]:
+        if self.engine == self.Engine.SYMPY:
+            return SympyPGF
+        elif self.engine == self.Engine.GINAC:
+            # pygin is optional (prodigy-ppl[ginac]); only the GiNaC engine imports it
+            try:
+                # pylint: disable=import-outside-toplevel
+                from prodigy.distribution.fast_generating_function import ProdigyPGF
+            except ImportError as error:
+                raise ConfigurationError(
+                    "The GiNaC engine needs pygin: pip install \"pygin @ "
+                    "git+https://github.com/LKlinke/prodigy-ginac-bindings.git@dynamic-variables\"") from error
+            return ProdigyPGF
+        elif self.engine == self.Engine.SYMENGINE:
+            return SymenginePGF
+        else:
+            return CommonDistributionsFactory
+
+    def __attrs_post_init__(self):
+        GeneratingFunction.use_latex_output = self.use_latex
+        GeneratingFunction.use_simplification = self.use_simplification

prodigy/analysis/equivalence/__init__.py

@@ -0,0 +1,9 @@
+"""
+====================
+Equivalence Checking
+====================
+
+This module performs equivalence checks on two probabilistic programs.
+
+.. automodule:: prodigy.analysis.forward.equivalence.equivalence_check
+"""