Create Problem

Create a PINA Problem — Entry Point

[!IMPORTANT] Read RULES.md before using this skill — it applies to all skills.

This is the entry-point skill for building PINA Problems. It selects the problem type and routes to sub-skills for the deep work.

Overview

A PINA problem is a Python class that inherits from one or more of:

Problems can mix base classes via multiple inheritance (e.g., SpatialProblem + TimeDependentProblem for space-time PDEs).

Required attributes per problem type

Interactive flow

Step 1 — Problem nature

Is your problem data-driven (you have input/target data) or physics-driven (you have a PDE/ODE with known equations)?

Data-driven → use BaseProblem. Load the condition-setup sub-skill for data types and conditions.

Physics-driven → go to Step 2.

If the user is unsure:

• Data-driven: Pairs (input, target), model learns to map one to the other.
• Physics-driven: Differential equation, model minimises residual at collocation points.

Step 2 — Select domain type(s)

Does your problem involve:

• Spatial variables only (e.g. x, y, z)? → SpatialProblem
• Time as well? → also inherit TimeDependentProblem
• Parameters that vary? → also inherit ParametricProblem
• Unknown parameters to be discovered? → also inherit InverseProblem

Choose the base class(es) that match.

Step 3 — Delegate to sub-skills

1. Load define-domains to create the domain objects (spatial_domain, temporal_domain, etc.).
2. Load define-equations to define PDEs/ODEs and boundary conditions.
3. Load condition-setup to bind equations/conditions to domains.
4. Return to this skill after conditions are defined to handle discretisation (see Step 7 in define-domains) and final verification.

Templates

Template 1: Data-driven (supervised)

import torch
from pina import Condition, LabelTensor
from pina.problem import BaseProblem

input_data = LabelTensor(torch.randn(100, 1), "x")
target_data = LabelTensor(torch.randn(100, 1), "y")

class MySupervisedProblem(BaseProblem):
    input_variables = ["x"]
    output_variables = ["y"]
    conditions = {
        "data": Condition(input=input_data, target=target_data),
    }

problem = MySupervisedProblem()

Template 2: Purely spatial (Poisson-like)

from pina.problem import SpatialProblem
from pina.domain import CartesianDomain
from pina import Condition
from pina.equation import Equation
from pina.equation.zoo import FixedValue

class MySpatialProblem(SpatialProblem):
    output_variables = ["u"]
    spatial_domain = CartesianDomain({"x": [0, 1], "y": [0, 1]})

    domains = {
        "D": spatial_domain,
        "boundary": spatial_domain.partial(),
    }

    conditions = {
        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
        "D": Condition(domain="D", equation=Equation(my_pde)),
    }

    def solution(self, pts):
        ...

Template 3: Space-time (Burgers-like)

from pina.problem import SpatialProblem, TimeDependentProblem
from pina.domain import CartesianDomain
from pina import Condition
from pina.equation import Equation
from pina.equation.zoo import FixedValue

class MySpaceTimeProblem(TimeDependentProblem, SpatialProblem):
    output_variables = ["u"]
    spatial_domain = CartesianDomain({"x": [-1, 1]})
    temporal_domain = CartesianDomain({"t": [0, 1]})

    domains = {
        "D": spatial_domain.update(temporal_domain),
        "ic": spatial_domain.update(CartesianDomain({"t": 0})),
        "boundary": spatial_domain.partial().update(temporal_domain),
    }

    conditions = {
        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
        "ic": Condition(domain="ic", equation=Equation(initial_cond)),
        "D": Condition(domain="D", equation=Equation(my_pde)),
    }

    def solution(self, pts):
        ...

Template 4: Inverse problem

from pina.problem import SpatialProblem, InverseProblem
from pina.domain import CartesianDomain
from pina import Condition
from pina.equation import Equation
from pina.equation.zoo import FixedValue

class MyInverseProblem(SpatialProblem, InverseProblem):
    output_variables = ["u"]
    spatial_domain = CartesianDomain({"x": [-2, 2], "y": [-2, 2]})
    unknown_parameter_domain = CartesianDomain({"mu1": [-1, 1], "mu2": [-1, 1]})

    domains = {
        "D": spatial_domain,
        "boundary": spatial_domain.partial(),
    }

    conditions = {
        "boundary": Condition(domain="boundary", equation=FixedValue(0.0)),
        "D": Condition(domain="D", equation=Equation(laplace_equation)),
        "data": Condition(input=input_data, target=target_data),
    }

Template 5: Parametric problem

from pina.problem import SpatialProblem, ParametricProblem
from pina.domain import CartesianDomain

class MyParametricProblem(SpatialProblem, ParametricProblem):
    output_variables = ["u"]
    spatial_domain = CartesianDomain({"x": [0, 1]})
    parameter_domain = CartesianDomain({"mu": [0.5, 2.0]})

    domains = {
        "D": spatial_domain.update(parameter_domain),
        ...
    }
    ...

Checklist

• output_variables is a list[str] naming the model outputs
• For data-driven: input_variables is a list[str] naming the inputs
• For physics-driven: all required domains are defined (spatial_domain, temporal_domain, parameter_domain, or unknown_parameter_domain as appropriate)
• domains dict contains a key for every domain referenced in conditions
• If equation was unknown: searched the web, presented the found formulation to the user, and confirmed before using
• PDE problem includes both the equation AND boundary/initial conditions
• problem.discretise_domain(n=..., mode=..., domains=...) called for each physics domain
• problem.are_all_domains_discretised is True after discretisation
• (Optional) solution(pts) method defined with correct analytical solution returning LabelTensor with output_variables labels