Chapter 2 · Java

Java: What is Artificial Intelligence?

Run this example

Edit and run the java example

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

AiSystemClassifier.java

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

/** Validates evidence-based descriptions of AI systems on independent axes. */
public class AiSystemClassifier {

enum Authority { INFORM, RECOMMEND, DRAFT, DECIDE, EXECUTE }

record SystemProfile(
            String name,
            String field,
            List<String> methods,
            String modelFamily,
            List<String> capabilities,
            String application,
            Authority authority,
            boolean learnedFromData,
            boolean usesDeepNetwork,
            boolean broadlyPretrained,
            boolean claimsLlm,
            List<String> controls) {}

static List<String> validate(SystemProfile profile) {
        List<String> errors = new ArrayList<>();
        Set<String> methods = lower(profile.methods());
        Set<String> capabilities = lower(profile.capabilities());
        Set<String> controls = lower(profile.controls());

if (profile.learnedFromData() && !methods.contains("machine learning")) {
            errors.add("learnedFromData requires Machine Learning in methods");
        }
        if (profile.usesDeepNetwork() && !profile.learnedFromData()) {
            errors.add("Deep Learning requires a learned model in this taxonomy");
        }
        if (profile.claimsLlm() && !profile.usesDeepNetwork()) {
            errors.add("an LLM claim requires a Deep Learning mechanism");
        }
        if (profile.claimsLlm() && !"Large Language Model".equals(profile.modelFamily())) {
            errors.add("claimsLlm conflicts with the declared model family");
        }
        if (profile.broadlyPretrained() && !profile.usesDeepNetwork()) {
            errors.add("this Foundation Model profile lacks broad learned pretraining");
        }
        if (capabilities.contains("generate") && "Generative AI".equals(profile.modelFamily())) {
            errors.add("Generative AI is a capability, not a model-family value");
        }
        if (profile.authority().ordinal() >= Authority.DECIDE.ordinal()) {
            Set<String> missing = new TreeSet<>(Set.of("authorization", "human escalation", "rollback"));
            missing.removeAll(controls);
            if (!missing.isEmpty()) {
                errors.add("decision authority is missing controls: " + String.join(", ", missing));
            }
        }
        if (profile.capabilities().isEmpty()) errors.add("at least one observable capability is required");
        if (profile.methods().isEmpty()) errors.add("at least one behavior-producing method is required");
        return errors;
    }

static Set<String> lower(List<String> values) {
        return values.stream().map(String::toLowerCase).collect(Collectors.toSet());
    }

static void describe(SystemProfile profile) {
        List<String> errors = validate(profile);
        System.out.println("\n" + profile.name());
        System.out.println("  field       : " + profile.field());
        System.out.println("  methods     : " + String.join(", ", profile.methods()));
        System.out.println("  model family: " + (profile.modelFamily() == null ? "none" : profile.modelFamily()));
        System.out.println("  capabilities: " + String.join(", ", profile.capabilities()));
        System.out.println("  application : " + profile.application());
        System.out.println("  authority   : " + profile.authority().name().toLowerCase());
        if (errors.isEmpty()) {
            System.out.println("  VALID       : evidence and authority contract are internally consistent");
        } else {
            errors.forEach(error -> System.out.println("  ERROR       : " + error));
        }
    }

static final List<SystemProfile> PROFILES = List.of(
            new SystemProfile("Deterministic payroll validation", "Business software",
                    List.of("explicit rules"), null, List.of("calculate", "validate"),
                    "payroll workflow", Authority.DECIDE, false, false, false, false,
                    List.of("authorization", "human escalation", "rollback")),
            new SystemProfile("Symbolic medical expert system", "Artificial Intelligence",
                    List.of("symbolic inference"), "knowledge base and rules", List.of("infer", "recommend"),
                    "clinical decision support", Authority.RECOMMEND, false, false, false, false,
                    List.of("human escalation")),
            new SystemProfile("Credit-risk prediction service", "Artificial Intelligence",
                    List.of("Machine Learning"), "gradient-boosted trees", List.of("predict", "rank"),
                    "underwriting workflow", Authority.RECOMMEND, true, false, false, false,
                    List.of("human escalation", "monitoring")),
            new SystemProfile("Enterprise policy assistant", "Artificial Intelligence",
                    List.of("Machine Learning", "retrieval", "deterministic validation"),
                    "Large Language Model", List.of("retrieve", "generate", "abstain"),
                    "employee policy workflow", Authority.INFORM, true, true, true, true,
                    List.of("authorization", "human escalation", "citation validation")),
            new SystemProfile("Invalid autonomous approval claim", "Artificial Intelligence",
                    List.of("Machine Learning"), "Generative AI", List.of("generate", "execute"),
                    "automatic claim approval", Authority.EXECUTE, true, false, false, true,
                    List.of("monitoring"))
    );

public static void main(String[] args) {
        PROFILES.forEach(AiSystemClassifier::describe);
    }
}

Output

Run the code to see output here.

Java - AI System Classifier

Purpose

The Java implementation mirrors the Python contract using records, enums, and explicit validation. It classifies field, method, model family, capability, application, and authority independently.

Contract

SystemProfile contains asserted evidence. validate rejects unsupported or contradictory assertions, including:

claiming an LLM without a Deep Learning mechanism,
using Generative AI as a model family,
granting decision or execution authority without authorization, escalation, and rollback controls.

Verified Behavior

Four profiles pass and the intentionally invalid automatic-approval profile reports multiple errors. A successful run must therefore contain both VALID and ERROR lines.

Architect Extension

Replace string values with versioned domain enums and serialize the profile as JSON attached to an architecture decision record. Add a policy that prevents a release when asserted authority exceeds the controls declared for the workflow.