One Second Solver / Algebry Inc.

My first company. A complete computer algebra system, born in a classroom at the Technological University of Panama.

The design decision that defined everything: don’t compute the answer, reproduce the reasoning. An inference engine with logical rules that picked the method the way a person would at the blackboard, and showed every intermediate step. A CAS that returns x²/2 is a calculator; one that explains why it chose trigonometric substitution over integration by parts is a tutor.

What it actually covered

Arithmetic, pre-algebra and algebra. Linear and quadratic equations and inequalities. Polynomial long division. Proving trigonometric identities and notable products. Limits by factoring, rationalisation and L’Hôpital. Derivatives, including the derivative by definition. Definite, trigonometric, substitution, by-parts, partial-fraction, trigonometric-substitution and Taylor series integrals. Differential equations.

Plus audio recognition to dictate a problem, interactive plots and a history of solved exercises.

What it proved

That a well-designed symbolic engine doesn’t need to learn from data to be useful — it needs someone to encode the reasoning correctly. Fifteen years on, that distinction between computing and explaining is exactly what separates an LLM that answers from one you can trust.

Winner of a national innovation contest in 2012 and of the EO Global Student Entrepreneur Award Panama in 2017, which took us to Frankfurt representing Panama.

The rule, in code

Integration by parts is not a formula you apply: it is a rule that first has to decide whether it applies, and then pick the split well.

$$\int u\,dv = uv - \int v\,du$$

/** ∫ u dv = uv − ∫ v du. Fires only if the integrand factors into
 *  something that differentiates well and something that integrates well. */
final class IntegrationByParts implements Rule {

    @Override
    public boolean applies(Node integrand) {
        return integrand.isProduct()
            && LIATE.classifiable(integrand.factors());
    }

    @Override
    public Step run(Node integrand, Variable x) {
        // LIATE decides which factor is u: logarithmic, inverse,
        // algebraic, trigonometric, exponential. The order matters.
        // Choosing badly does not give a wrong answer: it gives an
        // integral worse than the one you started with, and the engine
        // loops.
        Split s = LIATE.split(integrand.factors());

        Node du = Derivative.of(s.u(), x);
        Node v  = Integral.of(s.dv(), x);

        return Step.of(
            Difference.of(Product.of(s.u(), v), Integral.of(Product.of(v, du), x)),
            "Integration by parts with u = " + s.u() + ", dv = " + s.dv()
        );
    }
}

Every Step carries its justification as text because the answer was never the product: the explanation was. And Taylor series —

$$f(x)=\sum_{n=0}^{\infty}\frac{f^{(n)}(a)}{n!}\,(x-a)^n$$

— are just another rule in the same engine, with its own firing condition.

Sources

• La Prensa — "OSS, the app that helps with mathematics"
• La Estrella de Panamá — "OSS, a virtual maths tutor"
• La Estrella de Panamá — "They build a solver on the web"