Chapter 2 · Python

Python: What is Artificial Intelligence?

Run this example

Edit and run the python example

Change the source and run it here. Use the output panel to compare your result with the expected highlights below.

Unlock execution

ai_system_classifier.py

"""Validate evidence-based descriptions of AI systems on independent axes."""

from __future__ import annotations

from dataclasses import dataclass, field
from enum import IntEnum

class Authority(IntEnum):
    INFORM = 1
    RECOMMEND = 2
    DRAFT = 3
    DECIDE = 4
    EXECUTE = 5

@dataclass(frozen=True)
class SystemProfile:
    name: str
    field: str
    methods: tuple[str, ...]
    model_family: str | None
    capabilities: tuple[str, ...]
    application: str
    authority: Authority
    learned_from_data: bool = False
    uses_deep_network: bool = False
    broadly_pretrained: bool = False
    claims_llm: bool = False
    controls: tuple[str, ...] = field(default_factory=tuple)

def validate(profile: SystemProfile) -> list[str]:
    """Return contradictions and missing controls without hiding uncertainty."""
    errors: list[str] = []
    normalized_methods = {method.lower() for method in profile.methods}
    normalized_capabilities = {capability.lower() for capability in profile.capabilities}
    normalized_controls = {control.lower() for control in profile.controls}

if profile.learned_from_data and "machine learning" not in normalized_methods:
        errors.append("learned_from_data requires Machine Learning in methods")
    if profile.uses_deep_network and not profile.learned_from_data:
        errors.append("Deep Learning requires a learned model in this taxonomy")
    if profile.claims_llm and not profile.uses_deep_network:
        errors.append("an LLM claim requires a Deep Learning mechanism")
    if profile.claims_llm and profile.model_family != "Large Language Model":
        errors.append("claims_llm conflicts with the declared model family")
    if profile.broadly_pretrained and not profile.uses_deep_network:
        errors.append("this Foundation Model profile lacks broad learned pretraining")
    if "generate" in normalized_capabilities and profile.model_family == "Generative AI":
        errors.append("Generative AI is a capability, not a model-family value")

if profile.authority >= Authority.DECIDE:
        required = {"authorization", "human escalation", "rollback"}
        missing = sorted(required - normalized_controls)
        if missing:
            errors.append("decision authority is missing controls: " + ", ".join(missing))

if not profile.capabilities:
        errors.append("at least one observable capability is required")
    if not profile.methods:
        errors.append("at least one behavior-producing method is required")

return errors

def describe(profile: SystemProfile) -> None:
    errors = validate(profile)
    print(f"\n{profile.name}")
    print(f"  field       : {profile.field}")
    print(f"  methods     : {', '.join(profile.methods)}")
    print(f"  model family: {profile.model_family or 'none'}")
    print(f"  capabilities: {', '.join(profile.capabilities)}")
    print(f"  application : {profile.application}")
    print(f"  authority   : {profile.authority.name.lower()}")
    if errors:
        for error in errors:
            print(f"  ERROR       : {error}")
    else:
        print("  VALID       : evidence and authority contract are internally consistent")

PROFILES = (
    SystemProfile(
        name="Deterministic payroll validation",
        field="Business software",
        methods=("explicit rules",),
        model_family=None,
        capabilities=("calculate", "validate"),
        application="payroll workflow",
        authority=Authority.DECIDE,
        controls=("authorization", "human escalation", "rollback"),
    ),
    SystemProfile(
        name="Symbolic medical expert system",
        field="Artificial Intelligence",
        methods=("symbolic inference",),
        model_family="knowledge base and rules",
        capabilities=("infer", "recommend"),
        application="clinical decision support",
        authority=Authority.RECOMMEND,
        controls=("human escalation",),
    ),
    SystemProfile(
        name="Credit-risk prediction service",
        field="Artificial Intelligence",
        methods=("Machine Learning",),
        model_family="gradient-boosted trees",
        capabilities=("predict", "rank"),
        application="underwriting workflow",
        authority=Authority.RECOMMEND,
        learned_from_data=True,
        controls=("human escalation", "monitoring"),
    ),
    SystemProfile(
        name="Enterprise policy assistant",
        field="Artificial Intelligence",
        methods=("Machine Learning", "retrieval", "deterministic validation"),
        model_family="Large Language Model",
        capabilities=("retrieve", "generate", "abstain"),
        application="employee policy workflow",
        authority=Authority.INFORM,
        learned_from_data=True,
        uses_deep_network=True,
        broadly_pretrained=True,
        claims_llm=True,
        controls=("authorization", "human escalation", "citation validation"),
    ),
    SystemProfile(
        name="Invalid autonomous approval claim",
        field="Artificial Intelligence",
        methods=("Machine Learning",),
        model_family="Generative AI",
        capabilities=("generate", "execute"),
        application="automatic claim approval",
        authority=Authority.EXECUTE,
        learned_from_data=True,
        claims_llm=True,
        controls=("monitoring",),
    ),
)

def main() -> None:
    for profile in PROFILES:
        describe(profile)

if __name__ == "__main__":
    main()

Output

Run the code to see output here.

Example 1 - Classify an Enterprise Policy Assistant

Scenario

An employee asks, "Can I work from another country for six weeks?"

The application authenticates the employee, retrieves policy sections the employee is authorized to view, asks an LLM to draft an answer, checks that each policy claim has a citation, and routes exceptions to Global Mobility.

Six-Axis Classification

Axis	Classification	Evidence
Field	Artificial Intelligence and NLP	The system infers and generates language outputs
Method	retrieval, deterministic policy checks, and Deep Learning inference	Different components produce behavior differently
Model family	LLM Foundation Model	A broadly pretrained language model is adapted at request time
Capability	retrieve, generate, validate, and abstain	These are observable system behaviors
Application	employee policy assistant	The application includes identity, sources, UI, workflow, and telemetry
Authority	inform and recommend	It may not approve an employment or tax exception

Model Boundary

The LLM receives a question and authorized evidence, then proposes text. It does not authenticate the employee, decide document permissions, establish which policy version is authoritative, or approve an exception.

Failure Contract

The system must abstain or escalate when:

no authoritative source is retrieved,
sources conflict,
the requested policy is outside the employee's access rights,
a citation does not support the generated claim,
the user asks for an exception or binding decision,
the model or retrieval service is unavailable.

Architect Decision

Treat citations as structured evidence, not decoration. Store source ID, version, effective date, owner, and access decision with the trace. A response that cannot be reconstructed from authorized evidence is not auditable.

What This Teaches

The same system is simultaneously an AI application, an LLM-backed product, a retrieval workflow, and a controlled recommendation service. Those statements do not conflict because they describe different axes.

Example 2 - Runnable AI System Classifier

Objective

Use a transparent rule engine to classify several systems on independent axes and reject contradictory descriptions.

The program does not pretend to discover whether arbitrary software is AI. It shows what evidence an engineer must supply and which implications can be checked mechanically.

What the Program Validates

an LLM claim requires a learned Deep Learning mechanism,
a Foundation Model claim requires broad pretraining and reuse,
decide or execute authority requires explicit controls,
generation is a capability rather than a model family,
unresolved evidence is reported instead of silently forced into a category.

Verified Output

The examples include:

deterministic payroll validation,
a symbolic medical expert system,
a credit-risk model,
an enterprise policy assistant,
an intentionally contradictory profile.

The final profile must report validation errors. That failure is part of the example: a taxonomy tool should expose unsupported claims rather than make every product look like valid AI.

Engineering Exercise

Add a content-moderation workflow with:

a learned classifier,
deterministic legal-policy overrides,
human review for uncertain cases,
recommend rather than execute authority.

Then add one invalid version that grants execution authority without a review, fallback, or rollback control. The validator should reject it.

Production Extension

In a real architecture review, serialize this profile as an ADR attachment and link every asserted capability to evaluation evidence. The classifier is not a governance system; it is a small executable contract that makes ambiguous language visible during design review.