`0 ~ 0`

[baggepinnen]

import ModelingToolkitStandardLibrary.Mechanical.Rotational
using ModelingToolkit, Test
using ModelingToolkit: t_nounits as t, D_nounits as D
import ModelingToolkitStandardLibrary.Blocks
import Multibody
import Multibody.PlanarMechanics as Pl

    @component function TestSlipBasedWheel(; name)
        systems = @named begin
            slipBasedWheelJoint = Pl.SlipBasedWheelJoint(
                radius = 0.3,
                r = [1,0],
                mu_A = 0.8,
                mu_S = 0.4,
                N = 100,
                sAdhesion = 0.04,
                sSlide = 0.12,
                vAdhesion_min = 0.05,
                vSlide_min = 0.15,
                # w_roll = 10
            )
            prismatic = Pl.Prismatic(r = [0,1], s = 1, v = 0)
            revolute = Pl.Revolute(phi = 0, w = 0)
            fixed = Pl.Fixed()
            engineTorque = Rotational.ConstantTorque(tau_constant = 2)
            body = Pl.Body(m = 10, I = 1, gy=0, phi=0, w=0)
            inertia = Rotational.Inertia(J = 1, phi = 0, w = 0)
            constant = Blocks.Constant(k = 0)
        end

        pars = @parameters begin
        end

        vars = @variables begin
        end

        equations = Equation[
            connect(prismatic.frame_a, revolute.frame_b)
            connect(revolute.frame_a, fixed.frame_b)
            connect(engineTorque.flange, inertia.flange_a)
            connect(body.frame_a, prismatic.frame_b)
            connect(slipBasedWheelJoint.frame_a, prismatic.frame_b)
            connect(slipBasedWheelJoint.flange_a, inertia.flange_b)
            connect(constant.output, slipBasedWheelJoint.dynamicLoad)
        ]

        return System(equations, t; name, systems)
    end

    @named model = TestSlipBasedWheel()
    ssys = multibody(model)
    display(unknowns(ssys))
    prob = ODEProblem(ssys, [
        ssys.inertia.w => 1e-10, # This is important, at zero velocity, the friction is ill-defined
        ssys.revolute.frame_b.phi => 0,
        ssys.body.w => 0,
        D(ssys.revolute.frame_b.phi) => 0,
        D(ssys.prismatic.r0[2]) => 0,
    ], (0.0, 20.0))

ERROR: The equations of a system must involve the unknowns/observables. The following equations were found to have no unknowns/observables:
0 ~ 0

Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:44
  [2] check_no_parameter_equations(sys::System)
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/utils.jl:363
  [3] TearingState(sys::System, source_info::ModelingToolkitBase.EquationSourceInformation; check::Bool, sort_eqs::Bool)
    @ ModelingToolkitTearing ~/.julia/dev/StateSelection/lib/ModelingToolkitTearing/src/tearingstate.jl:104
  [4] TearingState
    @ ~/.julia/dev/StateSelection/lib/ModelingToolkitTearing/src/tearingstate.jl:93 [inlined]
  [5] __mtkcompile(sys::System; inputs::OrderedCollections.OrderedSet{…}, outputs::OrderedCollections.OrderedSet{…}, disturbance_inputs::OrderedCollections.OrderedSet{…}, sort_eqs::Bool, kwargs::@Kwargs{…})
    @ ModelingToolkit ~/.julia/dev/ModelingToolkit/src/systems/systems.jl:33
  [6] __mtkcompile
    @ ~/.julia/dev/ModelingToolkit/src/systems/systems.jl:23 [inlined]
  [7] _mtkcompile(sys::System; kwargs::@Kwargs{…})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/systems.jl:136
  [8] _mtkcompile
    @ ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/systems.jl:122 [inlined]
  [9] mtkcompile(sys::System; additional_passes::Tuple{}, inputs::Vector{…}, outputs::Vector{…}, disturbance_inputs::Vector{…}, split::Bool, kwargs::@Kwargs{…})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/systems.jl:95
 [10] mtkcompile
    @ ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/systems.jl:84 [inlined]
 [11] InitializationProblem{…}(sys::System, t::Float64, op::ModelingToolkitBase.AtomicArrayDict{…}; fast_path::Bool, guesses::Dict{…}, check_length::Bool, warn_initialize_determined::Bool, initialization_eqs::Vector{…}, fully_determined::Nothing, check_units::Bool, allow_incomplete::Bool, algebraic_only::Bool, time_dependent_init::Bool, initsys_mtkcompile_kwargs::@NamedTuple{}, kwargs::@Kwargs{…})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/problems/initializationproblem.jl:74
 [12] InitializationProblem
    @ ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/problems/initializationproblem.jl:20 [inlined]
 [13] #_#937
    @ ./none:-1 [inlined]
 [14] maybe_build_initialization_problem(sys::System, iip::Bool, op::ModelingToolkitBase.AtomicArrayDict{…}, t::Float64, guesses::Dict{…}; time_dependent_init::Bool, u0_constructor::Function, p_constructor::Function, floatT::Type, initialization_eqs::Vector{…}, use_scc::Bool, eval_expression::Bool, eval_module::Module, missing_guess_value::ModelingToolkitBase.MissingGuessValue.var"typeof(MissingGuessValue)", implicit_dae::Bool, kwargs::@Kwargs{…})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/problem_utils.jl:1124
 [15] process_SciMLProblem(constructor::Type, sys::System, op::Vector{…}; build_initializeprob::Bool, implicit_dae::Bool, t::Float64, guesses::Dict{…}, warn_initialize_determined::Bool, initialization_eqs::Vector{…}, eval_expression::Bool, eval_module::Module, fully_determined::Nothing, check_initialization_units::Bool, u0_eltype::Nothing, tofloat::Bool, u0_constructor::typeof(identity), p_constructor::typeof(identity), check_length::Bool, symbolic_u0::Bool, warn_cyclic_dependency::Bool, circular_dependency_max_cycle_length::Int64, circular_dependency_max_cycles::Int64, initsys_mtkcompile_kwargs::@NamedTuple{}, substitution_limit::Int64, use_scc::Bool, time_dependent_init::Bool, algebraic_only::Bool, missing_guess_value::ModelingToolkitBase.MissingGuessValue.var"typeof(MissingGuessValue)", allow_incomplete::Bool, is_initializeprob::Bool, kwargs::@Kwargs{…})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/systems/problem_utils.jl:1472
 [16] (ODEProblem{…})(sys::System, op::Vector{…}, tspan::Tuple{…}; callback::Nothing, check_length::Bool, eval_expression::Bool, expression::Type, eval_module::Module, check_compatibility::Bool, kwargs::@Kwargs{})
    @ ModelingToolkitBase ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/problems/odeproblem.jl:105
 [17] ODEProblem
    @ ~/.julia/dev/ModelingToolkit/lib/ModelingToolkitBase/src/problems/odeproblem.jl:96 [inlined]
 [18] ODEProblem
    @ ./none:-1 [inlined]
 [19] ODEProblem(sys::System, op::Vector{Pair{Num, Float64}}, tspan::Tuple{Float64, Float64})
    @ ModelingToolkitBase ./none:-1

[AayushSabharwal]

A bit of a preface before I describe the error:
The linear SCC pass takes a linear SCC, and codegens a linear solve for the entire SCC. It doesn't do tearing, because that can cause the SCC to be (more) singular.

unhack_system is a function which removes inline linear SCC solves, because a lot of places don't like them (initialization primary among these). An nxn linear solve is turned into n algebraic equations.

The error:
If an SCC contains both D(w) and w_t it'll contain the equation D(w) ~ w_t. When unhack_system does its thing, it'll turn D(w) into w_t because D(w) is not a valid variable. Thus now two of the entries in unknowns(unhack_system(sys)) are the same, and it contains a 0 ~ 0 equation.

I can probably "fix" this by just getting unhack_system to recognize such cases and remove the duplicate variable along with the 0 ~ 0 equation. That's the proximal solution to get this unblocked. Ideally it would be nice if the inline SCC pass recognized this case and just removed that equation from the SCC. That is equivalent to what alias elimination is supposed to do if I understand the Modia paper correctly. The problem then is that right now I don't fully understand what the current implementation of the pass actually does. It seems distinctly different from the paper and yet is vitally important, as evidenced by the failures in #4150.