Examples with Fst catdata.fqlpp.FunctorExp.Fst used on opensource projects

Example 1 with Fst

use of catdata.fqlpp.FunctorExp.Fst in project fql by CategoricalData.

the class PPParser method toFn.

private static FnExp toFn(Object o) {
    try {
        Tuple5 t5 = (Tuple5) o;
        if (t5.a.toString().equals("apply")) {
            Tuple5 t = (Tuple5) o;
            String f = t.b.toString();
            FnExp e = toFn(t.e);
            return new FnExp.Apply(f, e);
        }
        Tuple3 t3 = (Tuple3) t5.e;
        Map s = new HashMap<>();
        List l = (List) t5.b;
        for (Object y : l) {
            Pair yy = (Pair) toValue(y);
            if (s.containsKey(yy.first)) {
                throw new RuntimeException("Duplicate domain entry in " + o);
            }
            s.put(yy.first, yy.second);
        }
        SetExp t3a = toSet(t3.a);
        SetExp t3c = toSet(t3.c);
        return new Const(s::get, t3a, t3c);
    } catch (Exception e) {
    }
    try {
        Tuple3 p = (Tuple3) o;
        Object p2 = p.b;
        Object p3 = p.c;
        Object o1 = p.a;
        String p1 = p.a.toString();
        if (p1.equals("fst")) {
            return new FnExp.Fst(toSet(p2), toSet(p3));
        } else if (p1.equals("snd")) {
            return new FnExp.Snd(toSet(p2), toSet(p3));
        } else if (p1.equals("inl")) {
            return new FnExp.Inl(toSet(p2), toSet(p3));
        } else if (p1.equals("inr")) {
            return new FnExp.Inr(toSet(p2), toSet(p3));
        } else if (p1.equals("iso1")) {
            return new FnExp.Iso(true, toSet(p2), toSet(p3));
        } else if (p1.equals("iso2")) {
            return new FnExp.Iso(false, toSet(p2), toSet(p3));
        } else if (p1.equals("eval")) {
            return new FnExp.Eval(toSet(p2), toSet(p3));
        } else if (p2.toString().equals(";")) {
            return new FnExp.Comp(toFn(o1), toFn(p3));
        } else if (p2.toString().equals("*")) {
            return new FnExp.Prod(toFn(o1), toFn(p3));
        } else if (p2.toString().equals("+")) {
            return new FnExp.Case(toFn(o1), toFn(p3));
        }
        if (p1.equals("apply")) {
            return new FnExp.ApplyTrans(p2.toString(), toSet(p3));
        }
    } catch (RuntimeException re) {
    }
    try {
        org.jparsec.functors.Pair p = (org.jparsec.functors.Pair) o;
        String p1 = p.a.toString();
        Object p2 = p.b;
        switch(p1) {
            case "id":
                return new FnExp.Id(toSet(p2));
            case "curry":
                return new FnExp.Curry(toFn(p2));
            case "ff":
                return new FnExp.FF(toSet(p2));
            case "tt":
                return new FnExp.TT(toSet(p2));
            case "char":
                return new FnExp.Chr(toFn(p2));
            case "kernel":
                return new Krnl(toFn(p2));
            default:
                break;
        }
    } catch (RuntimeException re) {
    }
    if (o instanceof String) {
        return new FnExp.Var(o.toString());
    }
    if (o.toString().equals("true")) {
        return new Tru("true");
    } else if (o.toString().equals("false")) {
        return new Tru("false");
    } else if (o.toString().equals("and")) {
        return new Tru("and");
    } else if (o.toString().equals("or")) {
        return new Tru("or");
    } else if (o.toString().equals("not")) {
        return new Tru("not");
    } else if (o.toString().equals("implies")) {
        return new Tru("implies");
    }
    throw new RuntimeException();
}

Example 2 with Fst

use of catdata.fqlpp.FunctorExp.Fst in project fql by CategoricalData.

the class PPParser method toFtr.

private static FunctorExp toFtr(Object o) {
    try {
        Tuple5 p = (Tuple5) o;
        if (p.a.toString().equals("apply")) {
            FunctorExp f = toFtr(p.b);
            FunctorExp e = toFtr(p.e);
            return new Apply(f, e);
        }
        if (p.e.toString().equals("Set")) {
            return p.c.toString().equals("Set") ? toSetSet(o) : toInstConst(o);
        } else if (p.e.toString().equals("Cat")) {
            return toCatFtrConst(o);
        } else {
            if (p.e instanceof Tuple3) {
                Tuple3 t = (Tuple3) p.e;
                if ((t.a.toString().equals("Cat") || t.a.toString().equals("Set")) && t.b.toString().equals("^")) {
                    return toFinalConst(o);
                } else {
                    throw new RuntimeException();
                }
            }
            return toMapConst(o);
        }
    } catch (Exception e) {
    }
    try {
        Tuple3 p = (Tuple3) o;
        Object p2 = p.b;
        Object p3 = p.c;
        Object o1 = p.a;
        String p1 = p.a.toString();
        if (p1.equals("fst")) {
            return new Fst(toCat(p2), toCat(p3));
        } else if (p1.equals("snd")) {
            return new Snd(toCat(p2), toCat(p3));
        } else if (p1.equals("inl")) {
            return new Inl(toCat(p2), toCat(p3));
        } else if (p1.equals("inr")) {
            return new Inr(toCat(p2), toCat(p3));
        } else if (p1.equals("iso1")) {
            return new Iso(true, toCat(p2), toCat(p3));
        } else if (p1.equals("iso2")) {
            return new Iso(false, toCat(p2), toCat(p3));
        } else if (p1.equals("eval")) {
            return new Eval(toCat(p2), toCat(p3));
        } else if (p2.toString().equals(";")) {
            return new Comp(toFtr(o1), toFtr(p3));
        } else if (p2.toString().equals("*")) {
            return new Prod(toFtr(o1), toFtr(p3));
        } else if (p2.toString().equals("+")) {
            return new Case(toFtr(o1), toFtr(p3));
        } else if (p2.toString().equals("^")) {
            return new Exp(toFtr(o1), toFtr(p3));
        } else if (p1.equals("unit")) {
            return new One(toCat(p.b), toCat(p.c));
        } else if (p1.equals("void")) {
            return new Zero(toCat(p.b), toCat(p.c));
        } else if (p1.equals("pushout")) {
            return new Pushout(p.b.toString(), p.c.toString());
        }
    } catch (RuntimeException re) {
    }
    try {
        org.jparsec.functors.Pair p = (org.jparsec.functors.Pair) o;
        String p1 = p.a.toString();
        Object p2 = p.b;
        switch(p1) {
            case "id":
                return new Id(toCat(p2));
            case "prop":
                return new Prop(toCat(p2));
            case "curry":
                return new Curry(toFtr(p2));
            case "uncurry":
                return new Uncurry(toFtr(p2));
            case "delta":
            case "sigma":
            case "pi":
                return new Migrate(toFtr(p2), p1);
            case "ff":
                return new FF(toCat(p2));
            case "tt":
                return new TT(toCat(p2));
            case "dom":
                return new Dom(p2.toString(), true);
            case "cod":
                return new Dom(p2.toString(), false);
            case "pivot":
                return new Pivot(toFtr(p2), true);
            case "unpivot":
                return new Pivot(toFtr(p2), false);
            default:
                break;
        }
    } catch (RuntimeException re) {
    }
    if (o instanceof String) {
        return new Var(o.toString());
    }
    throw new RuntimeException("Bad: " + o);
}

Example 3 with Fst

use of catdata.fqlpp.FunctorExp.Fst in project fql by CategoricalData.

the class CatOps method visit.

@Override
public Functor visit(FQLPPProgram env, Pushout e) {
    Transform l = ENV.trans.get(e.l);
    if (l == null) {
        throw new RuntimeException("Missing transform: " + e.l);
    }
    Transform r = ENV.trans.get(e.r);
    if (r == null) {
        throw new RuntimeException("Missing transform: " + e.r);
    }
    if (!l.source.equals(r.source)) {
        throw new RuntimeException("Source functors do not match.");
    }
    Category<Object, Object> D = l.source.source;
    Set<String> objects = new HashSet<>();
    objects.add("A");
    objects.add("B");
    objects.add("C");
    Set<String> arrows = new HashSet<>();
    arrows.add("f");
    arrows.add("g");
    arrows.add("a");
    arrows.add("b");
    arrows.add("c");
    Map<String, String> sources = new HashMap<>();
    sources.put("f", "A");
    sources.put("g", "A");
    sources.put("a", "A");
    sources.put("b", "B");
    sources.put("c", "C");
    Map<String, String> targets = new HashMap<>();
    targets.put("f", "B");
    targets.put("g", "C");
    targets.put("a", "A");
    targets.put("b", "B");
    targets.put("c", "C");
    Map<Pair<String, String>, String> composition = new HashMap<>();
    composition.put(new Pair<>("a", "a"), "a");
    composition.put(new Pair<>("b", "b"), "b");
    composition.put(new Pair<>("c", "c"), "c");
    composition.put(new Pair<>("a", "f"), "f");
    composition.put(new Pair<>("a", "g"), "g");
    composition.put(new Pair<>("f", "b"), "f");
    composition.put(new Pair<>("g", "c"), "g");
    Map<String, String> identities = new HashMap<>();
    identities.put("A", "a");
    identities.put("B", "b");
    identities.put("C", "c");
    Category<String, String> span = new FiniteCategory<>(objects, arrows, sources, targets, composition, identities);
    Category<Pair<Object, String>, Pair<Object, String>> Dspan = FinCat.product(D, span);
    Functor<Pair<Object, String>, Pair<Object, String>, Object, Object> fst = FinCat.first(D, span);
    FUNCTION<Pair<Object, String>, Set> o = p -> {
        switch(p.second) {
            case "A":
                return (Set) l.source.applyO(p.first);
            case "B":
                return (Set) l.target.applyO(p.first);
            case "C":
                return (Set) r.target.applyO(p.first);
            default:
                throw new RuntimeException();
        }
    };
    FUNCTION<Pair<Object, String>, Fn> x = fp -> {
        Object f = fp.first;
        String p = fp.second;
        Object a = D.source(f);
        // Object b = D.target(f);
        // String i = span.source(p);
        String j = span.target(p);
        // Functor I = i == "A" ? l.source : i == "B" ? l.target : r.target;
        Functor J = Objects.equals(j, "A") ? l.source : Objects.equals(j, "B") ? l.target : r.target;
        // Fn If = (Fn) I.applyA(f);
        Fn Jf = (Fn) J.applyA(f);
        Transform P = Objects.equals(p, "f") ? l : Objects.equals(p, "g") ? r : Objects.equals(p, "a") ? Transform.id(l.source) : Objects.equals(p, "b") ? Transform.id(l.target) : Transform.id(r.target);
        // Fn Pb = (Fn) P.apply(b);
        Fn Pa = (Fn) P.apply(a);
        return Fn.compose(Pa, Jf);
    };
    Functor I = new Functor(Dspan, FinSet.FinSet0(), o, x);
    return FDM.sigmaF(fst).applyO(I);
}