Ejemplo n.º 1
0
  @Override
  public Transform visit(FQLProgram env, Whisker e) {
    Functor F = e.func.accept(env, this);
    Transform T = e.trans.accept(env, this);

    if (e.left) {
      return Transform.leftWhisker(F, T);
    } else {
      return Transform.rightWhisker(F, T);
    }
  }
Ejemplo n.º 2
0
 @Override
 public Transform visit(FQLProgram env, fql_lib.decl.TransExp.Comp e) {
   Transform l = e.l.accept(env, this);
   Transform r = e.r.accept(env, this);
   return Transform.compose(l, r);
 }
Ejemplo n.º 3
0
 @Override
 public Transform visit(FQLProgram env, fql_lib.decl.TransExp.Id e) {
   Functor ff = e.t.accept(env, this);
   return Transform.id(ff);
 }
Ejemplo n.º 4
0
  @Override
  public Functor visit(FQLProgram 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.FinCat.product(D, span);
    Functor<Pair<Object, String>, Pair<Object, String>, Object, Object> fst =
        FinCat.FinCat.first(D, span);

    FUNCTION<Pair<Object, String>, Set> o =
        p -> {
          if (p.second.equals("A")) {
            return (Set) l.source.applyO(p.first);
          } else if (p.second.equals("B")) {
            return (Set) l.target.applyO(p.first);
          } else if (p.second.equals("C")) {
            return (Set) r.target.applyO(p.first);
          } else {
            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 = j == "A" ? l.source : j == "B" ? l.target : r.target;
          Fn If = (Fn) I.applyA(f);
          Fn Jf = (Fn) J.applyA(f);
          Transform P =
              p == "f"
                  ? l
                  : p == "g"
                      ? r
                      : p == "a"
                          ? Transform.id(l.source)
                          : 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);
          /*			if (p.second.equals("f")) {
          	return (Fn) l.apply(p.first);
          } else if (p.second.equals("g")) {
          	return (Fn) r.apply(p.first);
          } else if (p.second.equals("a")) {
          	return (Fn) l.source.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "A")));
          } else if (p.second.equals("b")) {
          	return (Fn) l.target.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "B")));
          } else if (p.second.equals("c")) {
          	return (Fn) r.target.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "C")));
          } else {
          	throw new RuntimeException();
          } */
        };
    Functor I = new Functor(Dspan, FinSet.FinSet(), o, x);

    return FDM.sigmaF(fst).applyO(I);
  }
Ejemplo n.º 5
0
 @Override
 public Transform visit(FQLProgram env, PeterApply e) {
   Transform t = e.t.accept(env, this);
   Signature.Node n = t.source.source.toSig().new Node(e.node);
   return (Transform) t.apply(n);
 }
Ejemplo n.º 6
0
 @Override
 public Transform visit(FQLProgram env, ApplyTrans e) {
   Transform F = e.F.accept(env, this);
   Functor I = e.I.accept(env, this);
   return (Transform) F.apply(I);
 }