relationalai 0.13.5__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

relationalai/semantics/lqp/rewrite/unify_definitions.py

@@ -1,323 +0,0 @@
-from relationalai.semantics.metamodel.compiler import Pass
-from relationalai.semantics.metamodel import ir, builtins as rel_builtins, factory as f, visitor
-from relationalai.semantics.metamodel.typer import typer
-from relationalai.semantics.metamodel import helpers
-from relationalai.semantics.metamodel.util import FrozenOrderedSet, OrderedSet
-
-
-from typing import cast, Union, Optional, Iterable
-from collections import defaultdict
-
-# LQP does not support multiple definitions for the same relation. This pass unifies all
-# definitions for each relation into a single definition using a union.
-class UnifyDefinitions(Pass):
-    def __init__(self):
-        super().__init__()
-
-    def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
-        # Maintain a cache of renamings for each relation. These need to be consistent
-        # across all definitions of the same relation.
-        self.renamed_relation_args: dict[Union[ir.Value, ir.Relation], list[ir.Var]] = {}
-
-        root = cast(ir.Logical, model.root)
-        new_tasks = self.get_combined_multidefs(root)
-        return ir.Model(
-            model.engines,
-            model.relations,
-            model.types,
-            f.logical(
-                tuple(new_tasks),
-                root.hoisted,
-                root.engine,
-            ),
-            model.annotations,
-        )
-
-    def _get_heads(self, logical: ir.Logical) -> list[Union[ir.Update, ir.Output]]:
-        derives = []
-        for task in logical.body:
-            if isinstance(task, ir.Update) and task.effect == ir.Effect.derive:
-                derives.append(task)
-            elif isinstance(task, ir.Output):
-                derives.append(task)
-        return derives
-
-    def _get_non_heads(self, logical: ir.Logical) -> list[ir.Task]:
-        non_derives = []
-        for task in logical.body:
-            if not(isinstance(task, ir.Update) and task.effect == ir.Effect.derive) and not isinstance(task, ir.Output):
-                non_derives.append(task)
-        return non_derives
-
-    def _get_head_identifier(self, head: Union[ir.Update, ir.Output]) -> Optional[ir.Value]:
-        if isinstance(head, ir.Update):
-            return head.relation
-        else:
-            assert isinstance(head, ir.Output)
-            if len(head.aliases) < 2:
-                # For processing here, we need output to have at least the column marker
-                # `keys` or both `cols` and `col` markers, and also a key
-                return None
-
-            output_alias_names = helpers.output_alias_names(head.aliases)
-            output_vals = helpers.output_values(head.aliases)
-
-            # For normal outputs, the pattern is output[keys](cols, "col000" as 'col', ...)
-            if output_alias_names[0] == "cols" and output_alias_names[1] == "col":
-                return output_vals[1]
-            if output_alias_names[0] == "keys": # handle wide keys relation
-                return output_vals[0]
-
-            # For exports, the pattern is output[keys]("col000" as 'col', ...)
-            if helpers.is_export(head):
-                if output_alias_names[0] == "col":
-                    return output_vals[0]
-
-        return None
-
-    def get_combined_multidefs(self, root: ir.Logical) -> list[ir.Logical]:
-        # Step 1: Group tasks by the relation they define.
-        relation_to_tasks: dict[Union[None, ir.Value, ir.Relation], list[ir.Logical]] = defaultdict(list)
-
-        for task in root.body:
-            task = cast(ir.Logical, task)
-            task_heads = self._get_heads(task)
-
-            # Some relations do not need to be grouped, e.g., if they don't contain a
-            # derive. Use `None` as a placeholder key for these cases.
-            if len(task_heads) != 1:
-                relation_to_tasks[None].append(task)
-                continue
-
-            head_id = self._get_head_identifier(task_heads[0])
-            relation_to_tasks[head_id].append(task)
-
-        # Step 2: For each relation, combine all of the body definitions into a union.
-        result_tasks = []
-        for relation, tasks in relation_to_tasks.items():
-            # If there's only one task for the relation, or if grouping is not needed, then
-            # just keep the original tasks.
-            if len(tasks) == 1 or relation is None:
-                result_tasks.extend(tasks)
-                continue
-
-            result_tasks.append(self._combine_tasks_into_union(tasks))
-        return result_tasks
-
-    def _get_variable_mapping(self, logical: ir.Logical) -> dict[ir.Value, ir.Var]:
-        heads = self._get_heads(logical)
-        assert len(heads) == 1, "should only have one head in a logical at this stage"
-        head = heads[0]
-
-        var_mapping = {}
-        head_id = self._get_head_identifier(head)
-
-        if isinstance(head, ir.Update):
-            args_for_renaming = head.args
-        else:
-            assert isinstance(head, ir.Output)
-            output_alias_names = helpers.output_alias_names(head.aliases)
-            if output_alias_names[0] == "cols" and output_alias_names[1] == "col":
-                assert len(head.aliases) > 2
-
-                # For outputs, we do not need to rename the `cols` and `col` markers or the
-                # keys.
-                output_values = helpers.output_values(head.aliases)[2:]
-
-            elif output_alias_names[0] == "keys": # handle wide keys output
-                assert len(head.aliases) > 1
-                output_values = helpers.output_values(head.aliases)[1:]
-
-            else:
-                assert helpers.is_export(head) and output_alias_names[0] == "col"
-                assert len(head.aliases) > 1
-
-                # For exports, we do not need to rename the `col` marker or the keys.
-                output_values = helpers.output_values(head.aliases)[1:]
-
-            args_for_renaming = []
-            for v in output_values:
-                if head.keys and isinstance(v, ir.Var) and v in head.keys:
-                    continue
-                args_for_renaming.append(v)
-
-        if head_id not in self.renamed_relation_args:
-            renamed_vars = []
-            for (i, arg) in enumerate(args_for_renaming):
-                typ = typer.to_type(arg)
-                assert arg not in var_mapping, "args of update should be unique"
-                if isinstance(arg, ir.Var):
-                    var_mapping[arg] = ir.Var(typ, arg.name)
-                else:
-                    var_mapping[arg] = ir.Var(typ, f"arg_{i}")
-
-                renamed_vars.append(var_mapping[arg])
-            self.renamed_relation_args[head_id] = renamed_vars
-        else:
-            for (arg, var) in zip(args_for_renaming, self.renamed_relation_args[head_id]):
-                var_mapping[arg] = var
-
-        return var_mapping
-
-    def _rename_variables(self, logical: ir.Logical) -> ir.Logical:
-        class RenameVisitor(visitor.Rewriter):
-            def __init__(self, var_mapping: dict[ir.Value, ir.Var]):
-                super().__init__()
-                self.var_mapping = var_mapping
-
-            def _get_mapped_value(self, val: ir.Value) -> ir.Value:
-                if isinstance(val, tuple):
-                    return tuple(self._get_mapped_value(t) for t in val)
-                return self.var_mapping.get(val, val)
-
-            def _get_mapped_values(self, vals: Iterable[ir.Value]) -> list[ir.Value]:
-                return [self._get_mapped_value(v) for v in vals]
-
-            def handle_var(self, node: ir.Var, parent: ir.Node) -> ir.Var:
-                return self.var_mapping.get(node, node)
-
-            # TODO: ideally, extend the rewriter class to allow rewriting PyValue to Var so
-            # we don't need to separately handle all cases containing them.
-            def handle_update(self, node: ir.Update, parent: ir.Node) -> ir.Update:
-                return ir.Update(
-                    node.engine,
-                    node.relation,
-                    tuple(self._get_mapped_values(node.args)),
-                    node.effect,
-                    node.annotations,
-                )
-
-            def handle_lookup(self, node: ir.Lookup, parent: ir.Node) -> ir.Lookup:
-                return ir.Lookup(
-                    node.engine,
-                    node.relation,
-                    tuple(self._get_mapped_values(node.args)),
-                    node.annotations,
-                )
-
-            def handle_output(self, node: ir.Output, parent: ir.Node) -> ir.Output:
-                new_aliases = FrozenOrderedSet(
-                    [(name, self._get_mapped_value(value)) for name, value in node.aliases]
-                )
-                if node.keys:
-                    new_keys = FrozenOrderedSet(
-                        [self.var_mapping.get(key, key) for key in node.keys]
-                    )
-                else:
-                    new_keys = node.keys
-
-                return ir.Output(
-                    node.engine,
-                    new_aliases,
-                    new_keys,
-                    node.annotations,
-                )
-
-            def handle_construct(self, node: ir.Construct, parent: ir.Node) -> ir.Construct:
-                new_values = tuple(self._get_mapped_values(node.values))
-                new_id_var = self.var_mapping.get(node.id_var, node.id_var)
-                return ir.Construct(
-                    node.engine,
-                    new_values,
-                    new_id_var,
-                    node.annotations,
-                )
-
-            def handle_aggregate(self, node: ir.Aggregate, parent: ir.Node) -> ir.Aggregate:
-                new_projection = tuple(self.var_mapping.get(arg, arg) for arg in node.projection)
-                new_group = tuple(self.var_mapping.get(arg, arg) for arg in node.group)
-                new_args = tuple(self._get_mapped_values(node.args))
-                return ir.Aggregate(
-                    node.engine,
-                    node.aggregation,
-                    new_projection,
-                    new_group,
-                    new_args,
-                    node.annotations,
-                )
-
-            def handle_rank(self, node: ir.Rank, parent: ir.Node) -> ir.Rank:
-                new_projection = tuple(self.var_mapping.get(arg, arg) for arg in node.projection)
-                new_group = tuple(self.var_mapping.get(arg, arg) for arg in node.group)
-                new_args = tuple(self.var_mapping.get(arg, arg) for arg in node.args)
-                new_result = self.var_mapping.get(node.result, node.result)
-
-                return ir.Rank(
-                    node.engine,
-                    new_projection,
-                    new_group,
-                    new_args,
-                    node.arg_is_ascending,
-                    new_result,
-                    node.limit,
-                    node.annotations,
-                )
-
-        var_mapping = self._get_variable_mapping(logical)
-
-        renamer = RenameVisitor(var_mapping)
-        result = renamer.walk(logical)
-
-        # Also need to append the equality for each renamed constant. E.g., if the mapping
-        # contains (50.0::FLOAT -> arg_2::FLOAT), we need to add
-        # `eq(arg_2::FLOAT, 50.0::FLOAT)` to the result.
-        value_eqs = []
-        for (old_var, new_var) in var_mapping.items():
-            if not isinstance(old_var, ir.Var):
-                value_eqs.append(f.lookup(rel_builtins.eq, [new_var, old_var]))
-
-        return ir.Logical(
-            result.engine,
-            result.hoisted,
-            tuple(value_eqs) + tuple(result.body),
-            result.annotations,
-        )
-
-    # This function is the main workhorse for this rewrite pass. It takes a list of tasks
-    # that define the same relation, and combines them into a single task that defines
-    # the relation using a union of all of the bodies.
-    def _combine_tasks_into_union(self, tasks: list[ir.Logical]) -> ir.Logical:
-        # Step 1: Rename the variables in all tasks so that they will match the final derive
-        # after reconstructing into a union
-        renamed_tasks = [self._rename_variables(task) for task in tasks]
-
-        # Step 2: Get the final derive
-        derives = self._get_heads(renamed_tasks[0])
-        assert len(derives) == 1, "should only have one derive in a logical at this stage"
-        # Also make sure that all the derives are the same. This should be the case because
-        # we renamed all the variables to be the same in step 1.
-        for task in renamed_tasks[1:]:
-            assert self._get_heads(task) == derives, "all derives should be the same"
-
-        derive = derives[0]
-
-        # Step 3: Remove the final `derive` from each task
-        renamed_task_bodies = [
-            f.logical(
-                tuple(self._get_non_heads(t)),  # Only keep non-head tasks
-                t.hoisted,
-                t.engine,
-            )
-            for t in renamed_tasks
-        ]
-
-        # Deduplicate bodies
-        renamed_task_bodies = OrderedSet.from_iterable(renamed_task_bodies).get_list()
-
-        # Step 4: Construct a union of all the task bodies
-        if len(renamed_task_bodies) == 1:
-            # If there's only one body after deduplication, no need to create a union
-            new_body = renamed_task_bodies[0]
-        else:
-            new_body = f.union(
-                tuple(renamed_task_bodies),
-                [],
-                renamed_tasks[0].engine,
-            )
-
-        # Step 5: Add the final derive back
-        return f.logical(
-            (new_body, derive),
-            [],
-            renamed_tasks[0].engine,
-        )

relationalai/semantics/lqp/types.py

@@ -1,101 +0,0 @@
-from relationalai.semantics.metamodel import ir as meta
-from relationalai.semantics.metamodel import types
-from relationalai.semantics.lqp import ir as lqp
-from relationalai.semantics.lqp.constructors import mk_type, mk_value
-from typing import Union
-
-# LQP Integer type limits
-INT_MIN = -2**63 # LQP INT is a 64-bit signed integer
-INT_MAX = 2**63 - 1 # LQP INT is a 64-bit signed integer
-INT128_MIN = -2**127
-INT128_MAX = 2**127 - 1
-UINT128_MIN = 0
-UINT128_MAX = 2**128 - 1
-
-PrimitiveValue = Union[
-    str, int, float, lqp.UInt128Value, lqp.Int128Value, lqp.DecimalValue, lqp.DateValue,
-    lqp.DateTimeValue, lqp.BooleanValue
-]
-
-def is_numeric(type: lqp.Type) -> bool:
-    # UInt128 is used for hash, RowID, and entity ids so we don't include it as numeric
-    return type.type_name in {
-        lqp.TypeName.INT, lqp.TypeName.INT128, lqp.TypeName.FLOAT, lqp.TypeName.DECIMAL
-    }
-
-def meta_type_to_lqp(typ: meta.Type) -> lqp.Type:
-    if isinstance(typ, meta.UnionType):
-        # By this point, unions can only consist of entity types. In the LQP,
-        # they are undifferentiated (hashes), so they all merge.
-        assert all(types.is_entity_type(t) for t in typ.types), \
-            f"Union type {typ} contains non-entity types: " \
-            f"{[t for t in typ.types if not types.is_entity_type(t)]}"
-
-        return mk_type(lqp.TypeName.UINT128)
-    else:
-        assert isinstance(typ, meta.ScalarType)
-        if isinstance(typ, meta.DecimalType):
-            # deal first with decimals as they may be in the builtin set as well
-            return mk_type(lqp.TypeName.DECIMAL, [mk_value(typ.precision), mk_value(typ.scale)])
-        elif types.is_builtin(typ):
-            if typ == types.Int64:
-                return mk_type(lqp.TypeName.INT)
-            elif typ == types.Int128:
-                return mk_type(lqp.TypeName.INT128)
-            elif typ == types.Float:
-                return mk_type(lqp.TypeName.FLOAT)
-            elif typ == types.String:
-                return mk_type(lqp.TypeName.STRING)
-            elif typ == types.Date:
-                return mk_type(lqp.TypeName.DATE)
-            elif typ == types.DateTime:
-                return mk_type(lqp.TypeName.DATETIME)
-            elif typ == types.Hash:
-                return mk_type(lqp.TypeName.UINT128)
-            elif typ == types.RowId:
-                return mk_type(lqp.TypeName.UINT128)
-            elif typ == types.UInt128:
-                return mk_type(lqp.TypeName.UINT128)
-            elif typ == types.Bool:
-                return mk_type(lqp.TypeName.BOOLEAN)
-            elif typ == types.Number:
-                # All types must be specified in the LQP.
-                raise Exception("Number type could not be determined.")
-            elif types.is_any(typ):
-                # All types must be specified in the LQP.
-                raise Exception("Type could not be determined.")
-            else:
-                raise NotImplementedError(f"Unknown builtin type: {typ.name}")
-        elif types.is_entity_type(typ):
-            return mk_type(lqp.TypeName.UINT128)
-        else:
-            # Otherwise, the type extends some other type, we use that instead
-            assert len(typ.super_types) > 0, f"Type {typ} has no super types"
-            assert len(typ.super_types) == 1, f"Type {typ} has multiple super types: {typ.super_types}"
-            super_type = typ.super_types[0]
-            assert isinstance(super_type, meta.ScalarType), f"Super type {super_type} of {typ} is not a scalar type"
-            return meta_type_to_lqp(super_type)
-
-def lqp_type_to_sql(arg: lqp.Type) -> str:
-    if arg.type_name == lqp.TypeName.INT:
-        return "NUMBER(38, 0)"
-    elif arg.type_name == lqp.TypeName.FLOAT:
-        return "FLOAT"
-    elif arg.type_name == lqp.TypeName.STRING:
-        return "VARCHAR"
-    elif arg.type_name == lqp.TypeName.INT128:
-        return "NUMBER(38, 0)"
-    elif arg.type_name == lqp.TypeName.UINT128:
-        return "NUMBER(38, 0)"
-    elif arg.type_name == lqp.TypeName.DATE:
-        return "DATE"
-    elif arg.type_name == lqp.TypeName.DATETIME:
-        return "DATETIME"
-    elif arg.type_name == lqp.TypeName.DECIMAL:
-        assert len(arg.parameters) == 2, \
-            f"DECIMAL type must have 2 parameters, got {arg.parameters}"
-        precision = arg.parameters[0].value
-        scale = arg.parameters[1].value
-        return f"NUMBER({precision}, {scale})"
-    else:
-        raise NotImplementedError(f"Unknown relational value type: {arg}")

relationalai/semantics/lqp/utils.py

@@ -1,170 +0,0 @@
-from relationalai.semantics.lqp import ir as lqp
-from relationalai.semantics.metamodel import ir
-from relationalai.semantics.metamodel.helpers import sanitize
-from relationalai.semantics.metamodel.util import FrozenOrderedSet
-
-from dataclasses import dataclass
-from hashlib import sha256
-from typing import Tuple
-
-class UniqueNames:
-    def __init__(self):
-        # Track count of seen names
-        self.seen = dict[str, int]()
-        # Maps id to unique name
-        self.id_to_name = dict[int,str]()
-
-    def get_name(self, name: str) -> str:
-        # Names will eventually be sanitized, which could cause collisions, so we
-        # do the sanitization here.
-        name = '_' if name == '_' else sanitize(name)
-        if name not in self.seen:
-            self.seen[name] = 1
-            return f"{name}"
-
-        self.seen[name] += 1
-        id = self.seen[name]
-        # If the original name has a suffix we can get collisions with generated names,
-        # so test the new name.
-        while f"{name}_{id}" in self.seen:
-            id += 1
-            self.seen[name] = id
-        new_name = f"{name}_{id}"
-        self.seen[new_name] = 1
-        return new_name
-
-    # Get a unique name for the given id. If the id is already in the map, return the
-    # existing name. Otherwise, generate a new name using the suggested_name and
-    # store it in the map.
-    def get_name_by_id(self, id: int, suggested_name:str) -> str:
-        if id in self.id_to_name:
-            return self.id_to_name[id]
-
-        name = self.get_name(suggested_name)
-        self.id_to_name[id] = name
-        return name
-
-@dataclass(frozen=True)
-class ExportDescriptor:
-    relation_id: lqp.RelationId
-    column_name: str
-    column_number: int
-    column_type: lqp.Type
-
-class TranslationCtx:
-    def __init__(self, def_names: UniqueNames = UniqueNames()):
-        # TODO: comment these fields
-        self.def_names = def_names
-        self.var_names = UniqueNames()
-        self.output_names = UniqueNames()
-        # A counter for break rules generated during translation of while loops
-        self.break_rule_counter = 0
-        # Map relation IDs to their original names for debugging and pretty printing.
-        self.rel_id_to_orig_name = {}
-        self.output_ids: list[tuple[lqp.RelationId, str]] = []
-        self.export_descriptors: list[ExportDescriptor] = []
-
-def gen_rel_id(ctx: TranslationCtx, orig_name: str, suffix: str = "") -> lqp.RelationId:
-    relation_id = lqp.RelationId(id=lqp_hash(orig_name + suffix), meta=None)
-    ctx.rel_id_to_orig_name[relation_id] = orig_name
-    return relation_id
-
-def gen_unique_var(ctx: TranslationCtx, name_hint: str) -> lqp.Var:
-    """
-    Generate a new variable with a unique name based on the provided hint.
-    """
-    name = ctx.var_names.get_name(name_hint)
-    return lqp.Var(name=name, meta=None)
-
-def is_constant(arg, expected_type):
-    """
-    Check if the argument is a constant of the expected type.
-    """
-    if isinstance(arg, ir.Literal):
-        return is_constant(arg.value, expected_type)
-
-    return isinstance(arg, expected_type)
-
-def rename_vars_var(var: lqp.Var, var_map: dict[str, lqp.Var]) -> lqp.Var:
-    return var_map.get(var.name, var)
-
-def rename_vars_relterm(term: lqp.RelTerm, var_map: dict[str, lqp.Var]) -> lqp.RelTerm:
-    if isinstance(term, lqp.Var):
-        return rename_vars_var(term, var_map)
-    else:
-        return term  # Constants do not change
-
-def rename_vars_term(term: lqp.Term, var_map: dict[str, lqp.Var]) -> lqp.Term:
-    if isinstance(term, lqp.Var):
-        return rename_vars_var(term, var_map)
-    else:
-        return term  # Constants do not change
-
-def rename_vars_abstraction(abstraction: lqp.Abstraction, var_map: dict[str, lqp.Var]) -> lqp.Abstraction:
-    new_vars = [(var_map.get(var.name, var), typ) for (var, typ) in abstraction.vars]
-    new_value = rename_vars_formula(abstraction.value, var_map)
-    return lqp.Abstraction(vars=new_vars, value=new_value, meta=abstraction.meta)
-
-def rename_vars_formula(formula: lqp.Formula, var_map: dict[str, lqp.Var]) -> lqp.Formula:
-    if isinstance(formula, lqp.Primitive):
-        return lqp.Primitive(
-            name=formula.name,
-            terms=[rename_vars_relterm(term, var_map) for term in formula.terms],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.Atom):
-        return lqp.Atom(
-            name=formula.name,
-            terms=[rename_vars_term(term, var_map) for term in formula.terms],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.RelAtom):
-        return lqp.RelAtom(
-            name=formula.name,
-            terms=[rename_vars_relterm(term, var_map) for term in formula.terms],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.Not):
-        return lqp.Not(arg=rename_vars_formula(formula.arg, var_map), meta=formula.meta)
-    elif isinstance(formula, lqp.Exists):
-        return lqp.Exists(body=rename_vars_abstraction(formula.body, var_map), meta=None)
-    elif isinstance(formula, lqp.Reduce):
-        return lqp.Reduce(
-            op=formula.op,
-            body=rename_vars_abstraction(formula.body, var_map),
-            terms=[rename_vars_term(term, var_map) for term in formula.terms],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.FFI):
-        return lqp.FFI(
-            meta=formula.meta,
-            name=formula.name,
-            args=[rename_vars_abstraction(arg, var_map) for arg in formula.args],
-            terms=[rename_vars_term(term, var_map) for term in formula.terms]
-        )
-    elif isinstance(formula, lqp.Conjunction):
-        return lqp.Conjunction(
-            args=[rename_vars_formula(arg, var_map) for arg in formula.args],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.Disjunction):
-        return lqp.Disjunction(
-            args=[rename_vars_formula(arg, var_map) for arg in formula.args],
-            meta=formula.meta
-        )
-    elif isinstance(formula, lqp.Cast):
-        return lqp.Cast(
-            input=rename_vars_term(formula.input, var_map),
-            result=rename_vars_term(formula.result, var_map),
-            meta=formula.meta,
-        )
-    else:
-        raise NotImplementedError(f"Unknown formula type: {type(formula)}")
-
-def lqp_hash(node: str) -> int:
-    h = int.from_bytes(sha256(node.encode()).digest(), byteorder='big', signed=False)
-    # Ensure it's within the 128-bit range
-    return h % (2**128)
-
-def output_names(aliases: FrozenOrderedSet[Tuple[str, ir.Value]]) -> list[str]:
-    return [v[0] for v in aliases]

relationalai/semantics/lqp/validators.py

@@ -1,70 +0,0 @@
-from relationalai.semantics.metamodel import ir
-from typing import Union
-
-CompilableType = Union[
-    # Subgrouping
-    ir.Logical,
-    ir.Union,
-
-    # Loops
-    ir.Loop,
-    ir.Sequence,
-    ir.Break,
-
-    # Formulas
-    ir.Lookup,
-    ir.Exists,
-    ir.Construct,
-    ir.Not,
-
-    # Aggregations
-    ir.Aggregate,
-
-    # Rank
-    ir.Rank,
-
-    # Effects
-    ir.Output,
-    ir.Update,
-
-    # Constraints
-    ir.Require,
-]
-
-# Preconditions
-def assert_valid_input(model: ir.Model) -> None:
-    task = model.root
-
-    assert isinstance(task, ir.Logical), f"expected root to be logical task, got {type(task)}"
-    for subtask in task.body:
-        _assert_valid_subtask(subtask)
-
-def _assert_valid_subtask(task: ir.Task) -> None:
-    # TODO: assert what subtasks should look like
-    assert isinstance(task, (ir.Logical, ir.Sequence)), f"expected logical task, got {type(task)}"
-    _assert_task_compilable(task)
-
-def _assert_task_compilable(task: ir.Task) -> None:
-    assert isinstance(task, CompilableType), f"expected task to be compilable, got {type(task)}"
-    if isinstance(task, ir.Logical):
-        for subtask in task.body:
-            _assert_task_compilable(subtask)
-    elif isinstance(task, ir.Union):
-        for subtask in task.tasks:
-            _assert_task_compilable(subtask)
-    elif isinstance(task, ir.Update):
-        assert_valid_update(task)
-        effect = task.effect
-        assert effect == ir.Effect.derive, "only derive supported at the moment"
-    elif isinstance(task, ir.Sequence):
-        assert any(anno.relation.name == "script" for anno in task.annotations), "only @script sequences supported at the moment"
-        for subtask in task.tasks:
-            _assert_task_compilable(subtask)
-    elif isinstance(task, ir.Loop):
-        assert isinstance(task.body, ir.Sequence), f"expected loop body to be a sequence, got {type(task.body)}"
-        for subtask in task.body.tasks:
-            _assert_task_compilable(subtask)
-
-def assert_valid_update(update: ir.Update) -> None:
-    effect = update.effect
-    assert effect == ir.Effect.derive, "only derive supported at the moment"