Simple optimization¶

This is to test and illustrate a very basic case of optimization, with types $A$ and $B$ , a term $a : A$ and a function $f: A \to B$ . We have $f(a)$ as a generator initially, but this should drop out if we have high weight for entropy.

import $cp.bin.`provingground-core-jvm-4d3ce04.fat.jar`

import $cp.$

import provingground._ , interface._, HoTT._, learning._

import provingground._ , interface._, HoTT._, learning._

repl.pprinter() = {
  val p = repl.pprinter()
  p.copy(
    additionalHandlers = p.additionalHandlers.orElse {
      translation.FansiShow.fansiHandler
    }
  )
}

val A = "A" :: Type
val B = "B" :: Type
val a = "a" :: A
val f = "f"  :: (A ->: B)

A: Typ[Term] = A
B: Typ[Term] = B
a: Term = a
f: Func[Term, Term] = f

val ts = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution.unif(A, B))

ts: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)

val lp = LocalProver(ts).noIsles

lp: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

val tunedT = lp.tunedGenerators

tunedT: monix.eval.Task[FiniteDistribution[Term]] = Map(
  Suspend(
    monix.tail.internal.IterantFoldLeftL$$$Lambda$2587/1046500047@6baca90b
  ),
  provingground.learning.LocalProverStep$$Lambda$2588/322700629@53fe9479,
  0
)

import monix.execution.Scheduler.Implicits.global
val tunedF = tunedT.runToFuture

import monix.execution.Scheduler.Implicits.global

tunedF: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(FiniteDistribution(Vector(Weighted(a, 1.0))))

lp.nextState.runToFuture

res8: monix.execution.CancelableFuture[TermState] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.5051141267422002),
        Weighted(a, 0.26093982408138533),
        Weighted(f, 0.23394604917641446)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  )
)

lp.expressionEval.map(_.entropy()).runToFuture

res9: monix.execution.CancelableFuture[Expression] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Sum(
    Product(
      Sum(
        Sum(
          Product(
            Product(InitialVal(Elem(f(a), Terms)), Literal(-1.0)),
            Log(InitialVal(Elem(f(a), Terms)))
          ),
          Product(
            Product(InitialVal(Elem(f, Terms)), Literal(-1.0)),
            Log(InitialVal(Elem(f, Terms)))
          )
        ),
        Product(
          Product(InitialVal(Elem(a, Terms)), Literal(-1.0)),
          Log(InitialVal(Elem(a, Terms)))
        )
      ),
      Literal(1.0)
    ),
    Product(
      Sum(
        Product(
          Literal(0.5),
          Log(Quotient(Literal(0.5), FinalVal(Elem(a, Terms))))
        ),
        Product(
          Literal(0.5),
          Log(Quotient(Literal(0.5), FinalVal(Elem(f(a), Terms))))
        )
      ),
      Literal(1.0)
    )
  )
)

lp.expressionEval.flatMap(_.generatorIterant(1, 1, 0.0001).headOptionL).runToFuture

res10: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.31528231497765496),
        Weighted(f, 0.322614187136065),
        Weighted(a, 0.36210349788628)
      )
    )
  )
)

lp.expressionEval.flatMap(_.generatorIterant(1, 1, 0.0001).take(1000).lastOptionL).runToFuture

res11: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 1.4201583999412631E-4),
        Weighted(f, 7.326229362794384E-4),
        Weighted(a, 0.9991253612237264)
      )
    )
  )
)

lp.expressionEval.flatMap(_.generatorIterant(1, 10, 0.0001).take(1000).lastOptionL).runToFuture

res12: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(Weighted(f, 7.04117997499284E-4), Weighted(a, 0.9992958820025007))
    )
  )
)

lp.expressionEval.flatMap(_.generatorIterant(0.01, 10, 0.000001).take(1000).lastOptionL).runToFuture

res13: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 1.8895822838138518E-4),
        Weighted(f, 0.21754244130319234),
        Weighted(a, 0.7822686004684263)
      )
    )
  )
)

val lp0 = LocalProver(TermState(FiniteDistribution.unif(a, f(a)), FiniteDistribution.unif(A, B)), TermGenParams.zero)

lp0: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f(a), 0.5))),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0,
  1.0
)

lp0.tunedGenerators.runToFuture

res15: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(FiniteDistribution(Vector(Weighted(f(a), 0.5), Weighted(a, 0.5))))

val lp1 = LocalProver(TermState(FiniteDistribution(a -> 0.8, f(a) -> 0.2), FiniteDistribution.unif(A, B)), TermGenParams.zero)

lp1: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.8), Weighted(f(a), 0.2))),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0,
  1.0
)

lp1.tunedGenerators.runToFuture

res17: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(Weighted(f(a), 0.4999999999999993), Weighted(a, 0.5000000000000007))
  )
)

val lp2 = LocalProver(TermState(FiniteDistribution(a -> 0.8, f(a) -> 0.2), FiniteDistribution.unif(A, B)), TermGenParams.zero, klW = 0.00001)

lp2: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.8), Weighted(f(a), 0.2))),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0,
  1.0E-5
)

lp2.tunedGenerators.runToFuture

res19: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(FiniteDistribution(Vector(Weighted(a, 0.9999999999999999))))

val lp3 = LocalProver(TermState(FiniteDistribution(a -> 0.8, f(a) -> 0.2), FiniteDistribution.unif(A, B)), TermGenParams.zero, klW = 0.1)

lp3: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.8), Weighted(f(a), 0.2))),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0,
  0.1
)

lp3.tunedGenerators.runToFuture

res21: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.015801910393245217),
      Weighted(a, 0.9841980896067548)
    )
  )
)

val lp4 = LocalProver(TermState(FiniteDistribution(a -> 0.8, f(a) -> 0.2), FiniteDistribution.unif(A, B)), TermGenParams.zero, klW = 0.4)

lp4: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.8), Weighted(f(a), 0.2))),
    FiniteDistribution(Vector(Weighted(A, 0.5), Weighted(B, 0.5))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0,
  0.4
)

lp4.tunedGenerators.runToFuture

res23: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(Weighted(f(a), 0.49999999999998435), Weighted(a, 0.5000000000000158))
  )
)

lp.expressionEval.flatMap(_.generatorIterant(0.0001, 10, 0.000001).take(1000).lastOptionL).runToFuture

res24: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 1.8362784778685155E-4),
        Weighted(f, 0.2573471478854855),
        Weighted(a, 0.7424692242667277)
      )
    )
  )
)

lp.expressionEval.flatMap(_.generatorIterant(0.00001, 10, 0.00000001).take(1000).lastOptionL).runToFuture

res25: monix.execution.CancelableFuture[Option[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Some(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 1.8356886649594198E-4),
        Weighted(f, 0.25775284727824743),
        Weighted(a, 0.7420635838552566)
      )
    )
  )
)

The code seems correct, but there seems to almost be a phase transition, and for far more unequal weights than expected. The above seems to be the stable case.

val ts = TermState(FiniteDistribution.unif(a, f), FiniteDistribution(A -> 0.01, B -> 0.99))
val lp5 = LocalProver(ts,  hW = 0.0001).noIsles

ts: TermState = TermState(
  FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f, 0.5))),
  FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp5: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f, 0.5))),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0E-4,
  1.0
)

lp5.tunedGenerators.runToFuture

res27: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(Weighted(f, 0.48645649441869593), Weighted(a, 0.5135435055813041))
  )
)

val lp6 = LocalProver(ts,  hW = 0.1).noIsles

lp6: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f, 0.5))),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  0.1,
  1.0
)

lp6.tunedGenerators.runToFuture

res29: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(Weighted(f, 0.970867208792367), Weighted(a, 0.02913279120763298))
  )
)

val ts1 = TermState(FiniteDistribution.unif(a, f), FiniteDistribution(A -> 0.05, B -> 0.95))
val lp7 = LocalProver(ts1,  hW = 0.0001).noIsles

ts1: TermState = TermState(
  FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f, 0.5))),
  FiniteDistribution(Vector(Weighted(A, 0.05), Weighted(B, 0.95))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp7: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(Vector(Weighted(a, 0.5), Weighted(f, 0.5))),
    FiniteDistribution(Vector(Weighted(A, 0.05), Weighted(B, 0.95))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
  10000,
  10,
  1.0E-4,
  1.0
)

lp7.tunedGenerators.runToFuture

res31: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(Weighted(f, 0.48530231728265055), Weighted(a, 0.5146976827173494))
  )
)

lp7.expressionEval.map(_.initTerms).runToFuture

res32: monix.execution.CancelableFuture[Vector[Term]] = Success(Vector(f, a))

lp7.expressionEval.map(_.vars).runToFuture

res33: monix.execution.CancelableFuture[Vector[Expression]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    FinalVal(Elem(A, Typs)),
    InitialVal(Elem(A, Typs)),
    FinalVal(Elem(B, Typs)),
    InitialVal(Elem(B, Typs)),
    FinalVal(Event(Terms, Filter(WithTyp(B)))),
    FinalVal(Elem(f(a), Terms)),
    FinalVal(Elem(f, Terms)),
    InitialVal(Elem(f, Terms)),
    FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
    InitialVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
    FinalVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil))),
    InitialVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil))),
    InitialVal(Elem(Wrap(f), Funcs)),
    FinalVal(Elem(Wrap(f), Funcs)),
    FinalVal(Elem(A, TargetTyps)),
    FinalVal(Elem(a, Terms)),
    InitialVal(Elem(a, Terms)),
    FinalVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil))),
    FinalVal(Elem(B, TargetTyps))
  )
)

val ts2 = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution(A -> 0.01, B -> 0.99))
val lp8 = LocalProver(ts2,  hW = 0.0001).noIsles

ts2: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp8: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp8.tunedGenerators.runToFuture

res35: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.008352975813745006),
      Weighted(f, 0.3643174099017187),
      Weighted(a, 0.6273296142845364)
    )
  )
)

val ts3 = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution(A -> 0.05, B -> 0.95))
val lp9 = LocalProver(ts3,  hW = 0.0001).noIsles
val ts4 = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution(A -> 0.1, B -> 0.9))
val lp10 = LocalProver(ts4,  hW = 0.0001).noIsles

ts3: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.05), Weighted(B, 0.95))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp9: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.05), Weighted(B, 0.95))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...
ts4: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.1), Weighted(B, 0.9))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp10: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.1), Weighted(B, 0.9))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp9.tunedGenerators.runToFuture
lp10.tunedGenerators.runToFuture

res37_0: monix.execution.CancelableFuture[FiniteDistribution[Term]] = Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.0016384166835784267),
      Weighted(f, 0.3641638877259243),
      Weighted(a, 0.6341976955904972)
    )
  )
)
res37_1: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 8.141318390969435E-4),
      Weighted(f, 0.3582488995214191),
      Weighted(a, 0.6409369686394839)
    )
  )
)

val lp11 = LocalProver(ts2,  hW = 0.01).noIsles

lp11: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp11.tunedGenerators.runToFuture

res39: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.002254902978375091),
      Weighted(f, 0.07807967755141672),
      Weighted(a, 0.9196654194702082)
    )
  )
)

ts2

res40: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)

val lp12 = LocalProver(ts2,  hW = 0.00001, klW = 10).noIsles

lp12: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp12.tunedGenerators.runToFuture

res42: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 8.784548569259632E-4),
      Weighted(f, 0.29424729355651563),
      Weighted(a, 0.7048742515865584)
    )
  )
)

lp12.nextState.runToFuture

res43: monix.execution.CancelableFuture[TermState] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.5304835577110888),
        Weighted(a, 0.23475822114445552),
        Weighted(f, 0.23475822114445552)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  )
)

lp12.tripleT.runToFuture

res44: monix.execution.CancelableFuture[(FiniteDistribution[Term], Set[EquationNode], EqDistMemo[TermState])] = [running]

lp12.tripleTypT.runToFuture

res45: monix.execution.CancelableFuture[(FiniteDistribution[Typ[Term]], Set[EquationNode], EqDistMemo[TermState])] = Success(
  (
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Set(
      EquationNode(
        FinalVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil))),
        Product(
          Coeff(Init(AtCoord(FuncsWithDomain, A :: HNil))),
          InitialVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil)))
        )
      ),
      EquationNode(
        FinalVal(Elem(f(a), Terms)),
        Product(
          Product(
            Coeff(
              BaseThenCondition(
                ZipMapOpt(UnifApplnOpt, Funcs, Terms, Terms),
                AtCoord(FuncsWithDomain, A :: HNil),
                Restrict(FuncWithDom(A))
              )
            ),
            FinalVal(Elem(Wrap(f), Funcs))
          ),
          FinalVal(Elem(a, Terms))
        )
      ),
      EquationNode(
        FinalVal(Elem(f(a), Terms)),
        Product(
          Product(
            Coeff(
              BaseThenCondition(
                ZipMapOpt(UnifApplnOpt, Funcs, Terms, Terms),
                AtCoord(FuncsWithDomain, (A → B) :: HNil),
                Restrict(FuncWithDom((A → B)))
              )
            ),
            FinalVal(Elem(Wrap(f), Funcs))
...

val ts5 = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution(A -> 0.001, B -> 0.999))

ts5: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 0.001), Weighted(B, 0.999))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)

val lp13 = LocalProver(ts5, hW = 0.0001, klW= 10).noIsles

lp13: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.001), Weighted(B, 0.999))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp13.tunedGenerators.runToFuture

res48: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.009133692299872558),
      Weighted(f, 0.2912913884458096),
      Weighted(a, 0.6995749192543178)
    )
  )
)

val ts6 = TermState(FiniteDistribution.unif(a, f, f(a)), FiniteDistribution(A -> 0.0001, B -> 0.9999))
val lp14 = LocalProver(ts6, hW = 0.0001, klW= 10).noIsles

ts6: TermState = TermState(
  FiniteDistribution(
    Vector(
      Weighted(a, 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(f(a), 0.3333333333333333)
    )
  ),
  FiniteDistribution(Vector(Weighted(A, 1.0E-4), Weighted(B, 0.9999))),
  Vector(),
  FiniteDistribution(Vector()),
  FiniteDistribution(Vector()),
  Empty
)
lp14: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 1.0E-4), Weighted(B, 0.9999))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

lp14.tunedGenerators.runToFuture

res50: monix.execution.CancelableFuture[FiniteDistribution[Term]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.11018771010724608),
      Weighted(f, 0.2803408020718488),
      Weighted(a, 0.6094714878209051)
    )
  )
)

Conclusions¶

After experimentation with the rather simple generation, we find

qualitatively stuff works, so seems to not have bugs
however perhaps because of logarithmic scaling, it takes surprising effort to get changes: specifically to have $f(a)$ in the generating set.

lp14.expressionEval.map(_.finalDist).runToFuture

res51: monix.execution.CancelableFuture[Map[Expression, Double]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Map(
    Coeff(
      BaseThenCondition(
        FiberProductMap(typeOf(_), FuncsWithDomain, FlipAppn, Terms, Terms),
        AtCoord(FuncsWithDomain, (A → B) :: HNil),
        Restrict(FuncWithDom((A → B)))
      )
    ) -> 0.1,
    Coeff(
      BaseThenCondition(
        FiberProductMap(typeOf(_), FuncsWithDomain, FlipAppn, Terms, Terms),
        AtCoord(FuncsWithDomain, A :: HNil),
        Restrict(FuncWithDom(A))
      )
    ) -> 0.1,
    InitialVal(Elem(A, Typs)) -> 1.0E-4,
    FinalVal(Elem(A, Typs)) -> 7.500000000000001E-5,
    InitialVal(Elem(B, Typs)) -> 0.9999,
    FinalVal(Elem(B, Typs)) -> 0.749925,
    FinalVal(Event(Terms, Filter(WithTyp(B)))) -> 0.8451889941533142,
    InitialVal(Elem(f(a), Terms)) -> 0.3333333333333333,
    FinalVal(Elem(f(a), Terms)) -> 0.5451468330533219,
    InitialVal(Elem(f, Terms)) -> 0.3333333333333333,
    FinalVal(Elem(f, Terms)) -> 0.21666666666666667,
    Coeff(
      BaseThenCondition(
        ZipMapOpt(UnifApplnOpt, Funcs, Terms, Terms),
        AtCoord(TermsWithTyp, A :: HNil),
        Filter(WithTyp(A))
      )
    ) -> 0.1,
    Coeff(
      BaseThenCondition(
        FiberProductMap(typeOf(_), FuncsWithDomain, FlipAppn, Terms, Terms),
        AtCoord(TermsWithTyp, A :: HNil),
        Filter(WithTyp(A))
      )
    ) -> 0.1,
...

import GeneratorVariables._, Expression._, TermRandomVars._
lp14.expressionEval.map(_.finalDist(FinalVal(Elem(f(a), Terms)))).runToFuture

import GeneratorVariables._, Expression._, TermRandomVars._

res52_1: monix.execution.CancelableFuture[Double] = Success(0.5451468330533219)

lp14.expressionEval.map(_.entropy(0.0001, 10)).runToFuture

res53: monix.execution.CancelableFuture[Expression] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Sum(
    Product(
      Sum(
        Sum(
          Product(
            Product(InitialVal(Elem(f(a), Terms)), Literal(-1.0)),
            Log(InitialVal(Elem(f(a), Terms)))
          ),
          Product(
            Product(InitialVal(Elem(f, Terms)), Literal(-1.0)),
            Log(InitialVal(Elem(f, Terms)))
          )
        ),
        Product(
          Product(InitialVal(Elem(a, Terms)), Literal(-1.0)),
          Log(InitialVal(Elem(a, Terms)))
        )
      ),
      Literal(1.0E-4)
    ),
    Product(
      Sum(
        Product(
          Literal(1.0000000000000003E-4),
          Log(
            Quotient(Literal(1.0000000000000003E-4), FinalVal(Elem(a, Terms)))
          )
        ),
        Product(
          Literal(0.9999000000000001),
          Log(
            Quotient(Literal(0.9999000000000001), FinalVal(Elem(f(a), Terms)))
          )
        )
      ),
      Literal(10.0)
    )
  )
)

val epT = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    entp <- ev.WithP(q).entropyProjectionTask(lp14.hW, lp14.klW)
} yield entp

epT: monix.eval.Task[Vector[Double]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd55$Helper$$Lambda$3730/1927048972@4966d36a,
    0
  ),
  ammonite.$sess.cmd55$Helper$$Lambda$3731/1848353081@d29c2ee
)

val epF = epT.runToFuture

epF: monix.execution.CancelableFuture[Vector[Double]] = Success(
  Vector(
    0.0,
    0.0,
    -6.401470818706567E-9,
    -1.600847815954079E-5,
    -0.9516685364522156,
    -0.748338326507673,
    -0.8091061373976427,
    1.081596818622833E-6,
    1.2708762618818288E-6,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    2.222297586595914E-16,
    0.0,
    -0.45789055309033405,
    -0.3896940877364547,
    0.0,
    -0.960177817271385,
    -2.0655501146299438E-9
  )
)

val entT = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    der <- ev.WithP(q).jetTask(ev.entropy(lp14.hW, lp14.klW))
} yield der

entT: monix.eval.Task[spire.math.Jet[Double]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd59$Helper$$Lambda$3757/374477152@d937b1a,
    0
  ),
  ammonite.$sess.cmd59$Helper$$Lambda$3758/1137030304@22abf70c
)

val entF = entT.runToFuture

entF: monix.execution.CancelableFuture[spire.math.Jet[Double]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Jet(
    6.057823287551792,
    Array(
      0.0,
      0.0,
      0.0,
      0.0,
      0.0,
      -4.548076816299835,
      2.1913841926246653E-6,
      0.0,
      2.1913841926246653E-6,
      0.0,
      0.0,
      0.0,
      0.0,
      0.0,
      0.0,
      0.0,
      2.1913841926246653E-6,
      -7.833333333333337E-4,
      0.0,
      0.0,
      0.0
    )
  )
)

val varT = for {
    ev <- lp14.expressionEval
    vs = ev.vars
} yield vs

varT: monix.eval.Task[Vector[Expression]] = Map(
  Async(<function2>, false, true, true),
  scala.Function1$$Lambda$275/1928301845@48647e19,
  1
)

val varsF = varT.runToFuture

varsF: monix.execution.CancelableFuture[Vector[Expression]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    FinalVal(Elem(A, Typs)),
    InitialVal(Elem(A, Typs)),
    FinalVal(Elem(B, Typs)),
    InitialVal(Elem(B, Typs)),
    FinalVal(Event(Terms, Filter(WithTyp(B)))),
    FinalVal(Elem(f(a), Terms)),
    InitialVal(Elem(f(a), Terms)),
    FinalVal(Elem(f, Terms)),
    InitialVal(Elem(f, Terms)),
    FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
    InitialVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
    FinalVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil))),
    InitialVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil))),
    InitialVal(Elem(Wrap(f), Funcs)),
    FinalVal(Elem(Wrap(f), Funcs)),
    FinalVal(Elem(A, TargetTyps)),
    InitialVal(Elem(a, Terms)),
    FinalVal(Elem(a, Terms)),
    InitialVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil))),
    FinalVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil))),
    FinalVal(Elem(B, TargetTyps))
  )
)

val klT0 = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    vs = ev.vars
    der <- ev.WithP(q).jetTask(ev.entropy(0, 1))
} yield der.infinitesimal.toVector.zip(vs)

klT0: monix.eval.Task[Vector[(Double, Expression)]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd67$Helper$$Lambda$3819/1270999907@423e2c4c,
    0
  ),
  ammonite.$sess.cmd67$Helper$$Lambda$3820/1258644324@1c4c4968
)

val klF0 = klT0.runToFuture

klF0: monix.execution.CancelableFuture[Vector[(Double, Expression)]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    (0.0, FinalVal(Elem(A, Typs))),
    (0.0, InitialVal(Elem(A, Typs))),
    (0.0, FinalVal(Elem(B, Typs))),
    (0.0, InitialVal(Elem(B, Typs))),
    (0.0, FinalVal(Event(Terms, Filter(WithTyp(B))))),
    (-0.4548076816299835, FinalVal(Elem(f(a), Terms))),
    (0.0, InitialVal(Elem(f(a), Terms))),
    (0.0, FinalVal(Elem(f, Terms))),
    (0.0, InitialVal(Elem(f, Terms))),
    (0.0, FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil)))),
    (0.0, InitialVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil)))),
    (0.0, FinalVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil)))),
    (0.0, InitialVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil)))),
    (0.0, InitialVal(Elem(Wrap(f), Funcs))),
    (0.0, FinalVal(Elem(Wrap(f), Funcs))),
    (0.0, FinalVal(Elem(A, TargetTyps))),
    (0.0, InitialVal(Elem(a, Terms))),
    (-7.833333333333337E-5, FinalVal(Elem(a, Terms))),
    (0.0, InitialVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil)))),
    (0.0, FinalVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil)))),
    (0.0, FinalVal(Elem(B, TargetTyps)))
  )
)

val entT0 = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    vs = ev.vars
    der <- ev.WithP(q).jetTask(ev.entropy(1, 0))
} yield der.infinitesimal.toVector.zip(vs)

entT0: monix.eval.Task[Vector[(Double, Expression)]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd76$Helper$$Lambda$3887/1263669105@75c4f276,
    0
  ),
  ammonite.$sess.cmd76$Helper$$Lambda$3888/1106007152@463b20c7
)

val entF0 = entT0.runToFuture

entF0: monix.execution.CancelableFuture[Vector[(Double, Expression)]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    (0.0, FinalVal(Elem(A, Typs))),
    (0.0, InitialVal(Elem(A, Typs))),
    (0.0, FinalVal(Elem(B, Typs))),
    (0.0, InitialVal(Elem(B, Typs))),
    (0.0, FinalVal(Event(Terms, Filter(WithTyp(B))))),
    (0.0, FinalVal(Elem(f(a), Terms))),
    (0.021913841926246652, InitialVal(Elem(f(a), Terms))),
    (0.0, FinalVal(Elem(f, Terms))),
    (0.021913841926246652, InitialVal(Elem(f, Terms))),
    (0.0, FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil)))),
    (0.0, InitialVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil)))),
    (0.0, FinalVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil)))),
    (0.0, InitialVal(Elem(Wrap(f), AtCoord(FuncsWithDomain, A :: HNil)))),
    (0.0, InitialVal(Elem(Wrap(f), Funcs))),
    (0.0, FinalVal(Elem(Wrap(f), Funcs))),
    (0.0, FinalVal(Elem(A, TargetTyps))),
    (0.021913841926246652, InitialVal(Elem(a, Terms))),
    (0.0, FinalVal(Elem(a, Terms))),
    (0.0, InitialVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil)))),
    (0.0, FinalVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil)))),
    (0.0, FinalVal(Elem(B, TargetTyps)))
  )
)

lp14.expressionEval.map(_.klExp).runToFuture

res71: monix.execution.CancelableFuture[Expression] = Success(
  Sum(
    Product(
      Literal(1.0000000000000003E-4),
      Log(Quotient(Literal(1.0000000000000003E-4), FinalVal(Elem(a, Terms))))
    ),
    Product(
      Literal(0.9999000000000001),
      Log(Quotient(Literal(0.9999000000000001), FinalVal(Elem(f(a), Terms))))
    )
  )
)

val shT = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    vs = ev.vars
    der <- ev.WithP(q).jetTask(ev.entropy(0, 1))
    gs = ev.gradShift(q, der.infinitesimal.toVector, 1).toVector.collect{case (k, v) if q(k) != v   => (k, q(k), v)}
} yield gs

shT: monix.eval.Task[Vector[(Expression, Double, Double)]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd83$Helper$$Lambda$4028/872933634@29ee3614,
    0
  ),
  ammonite.$sess.cmd83$Helper$$Lambda$4029/652523674@2f9bb5e1
)

val shF = shT.runToFuture

shF: monix.execution.CancelableFuture[Vector[(Expression, Double, Double)]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    (InitialVal(Elem(A, Typs)), 1.0E-4, 9.999999999999999E-5),
    (FinalVal(Elem(A, Typs)), 7.500000000000001E-5, 7.499999999999994E-5),
    (FinalVal(Elem(f(a), Terms)), 0.5451468330533219, 0.6538233924516196),
    (FinalVal(Elem(f, Terms)), 0.21666666666666667, 0.21666666666666662),
    (
      FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
      0.19500000000000003,
      0.195
    ),
    (
      FinalVal(Elem(A, TargetTyps)),
      2.2500000000000005E-5,
      2.2500000000000015E-5
    ),
    (FinalVal(Elem(a, Terms)), 0.21666666666666667, 0.21667996186914693),
    (FinalVal(Elem(B, TargetTyps)), 0.22497750000000002, 0.22497750000000005)
  )
)

We note that the entropy shift increases the final value of the probability of $f(a)$ , as it should be. Next we check directly for the generator iterant, but in this case initially.

val probT = for {
    ev <- lp14.expressionEval
    prob <- ev.generatorIterant(0, 1, 0.000001, ev.finalDist).map(_(f(a))).take(20).toListL
} yield prob

probT: monix.eval.Task[List[Double]] = FlatMap(
  Async(<function2>, false, true, true),
  ammonite.$sess.cmd90$Helper$$Lambda$4081/1982913167@232b117f
)

val probF = probT.runToFuture

probF: monix.execution.CancelableFuture[List[Double]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  List(
    0.34181842078269037,
    0.3418134918158566,
    0.341808543904923,
    0.3418035960540994,
    0.341798648253904,
    0.3417937005043447,
    0.3417887528054228,
    0.3417838051571398,
    0.34177885755949705,
    0.341773910012496,
    0.3417689625161379,
    0.34176401507042437,
    0.3417590676753567,
    0.3417541203309363,
    0.34174917303716446,
    0.34174422579404273,
    0.3417392786015725,
    0.3417343314597551,
    0.341729384368592,
    0.3417244373280846
  )
)

val pshT = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    vs = ev.vars
    der <- ev.WithP(q).entropyProjectionTask(0, 1)
    gs = ev.gradShift(q, der, 1).toVector.collect{case (k, v) if q(k) != v   => (k, q(k), v)}
} yield gs

pshT: monix.eval.Task[Vector[(Expression, Double, Double)]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd92$Helper$$Lambda$4105/831437506@5b27c107,
    0
  ),
  ammonite.$sess.cmd92$Helper$$Lambda$4106/255065230@1b95d47e
)

val pshF = pshT.runToFuture

pshF: monix.execution.CancelableFuture[Vector[(Expression, Double, Double)]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  Vector(
    (InitialVal(Elem(A, Typs)), 1.0E-4, 9.999999999999999E-5),
    (FinalVal(Elem(A, Typs)), 7.500000000000001E-5, 7.499999999999994E-5),
    (InitialVal(Elem(B, Typs)), 0.9999, 0.9999000001600683),
    (FinalVal(Elem(B, Typs)), 0.749925, 0.7499250001200513),
    (
      FinalVal(Event(Terms, Filter(WithTyp(B)))),
      0.8451889941533142,
      0.8572362199059654
    ),
    (InitialVal(Elem(f(a), Terms)), 0.3333333333333333, 0.3515491903542607),
    (FinalVal(Elem(f(a), Terms)), 0.5451468330533219, 0.5636317002920135),
    (FinalVal(Elem(f, Terms)), 0.21666666666666667, 0.21666666666666662),
    (
      FinalVal(Elem(a, AtCoord(TermsWithTyp, A :: HNil))),
      0.19500000000000003,
      0.195
    ),
    (
      FinalVal(Elem(A, TargetTyps)),
      2.2500000000000005E-5,
      2.2500000000000015E-5
    ),
    (InitialVal(Elem(a, Terms)), 0.3333333333333333, 0.34358513334882024),
    (FinalVal(Elem(a, Terms)), 0.21666666666666667, 0.22335363387809662),
    (
      FinalVal(Elem(f(a), AtCoord(TermsWithTyp, B :: HNil))),
      0.8468645432598687,
      0.8589063147463998
    ),
    (FinalVal(Elem(B, TargetTyps)), 0.22497750000000002, 0.22497750003601544)
  )
)

val prstshT = for {
    ev <- lp14.expressionEval
    q = ev.finalDist
    vs = ev.vars
    der <- ev.WithP(q).entropyProjectionTask(0, 1)
    gs = ev.stableGradShift(q, der, 1).toVector.collect{case (k @ InitialVal(Elem(_, Terms)), v) if q(k) != v   => (k, q(k), v)}
} yield gs

prstshT: monix.eval.Task[Vector[(InitialVal[Any], Double, Double)]] = FlatMap(
  Map(
    Async(<function2>, false, true, true),
    ammonite.$sess.cmd96$Helper$$Lambda$4154/1771170652@20608417,
    0
  ),
  ammonite.$sess.cmd96$Helper$$Lambda$4155/1792142115@60fcba35
)

val prstshF = prstshT.runToFuture

prstshF: monix.execution.CancelableFuture[Vector[(InitialVal[Any], Double, Double)]] = Success(
  Vector(
    (InitialVal(Elem(f(a), Terms)), 0.3333333333333333, 0.34181842078269037),
    (InitialVal(Elem(f, Terms)), 0.3333333333333333, 0.3241067728798118),
    (InitialVal(Elem(a, Terms)), 0.3333333333333333, 0.33407480633749786)
  )
)

import ExpressionEval._

import ExpressionEval._

val ev14 = lp14.expressionEval

ev14: monix.eval.Task[ExpressionEval] = Async(<function2>, false, true, true)

val gT = ev14.map(e => generators(e.finalDist))
val gF = gT.runToFuture

gT: monix.eval.Task[FiniteDistribution[Term]] = Map(
  Async(<function2>, false, true, true),
  ammonite.$sess.cmd100$Helper$$Lambda$4176/1278192073@57f79b6a,
  0
)
gF: monix.execution.CancelableFuture[FiniteDistribution[Term]] = Success(
  FiniteDistribution(
    Vector(
      Weighted(f(a), 0.3333333333333333),
      Weighted(f, 0.3333333333333333),
      Weighted(a, 0.3333333333333333)
    )
  )
)

val gT = ev14.flatMap(e => e.generatorIterant(0, 1, 0.000001, e.finalDist).take(20).toListL)

gT: monix.eval.Task[List[FiniteDistribution[Term]]] = FlatMap(
  Async(<function2>, false, true, true),
  ammonite.$sess.cmd112$Helper$$Lambda$4241/1657741802@67d07157
)

val gF = gT.runToFuture

gF: monix.execution.CancelableFuture[List[FiniteDistribution[Term]]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  List(
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.34181842078269037),
        Weighted(f, 0.3241067728798118),
        Weighted(a, 0.33407480633749786)
      )
    ),
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.3418134918158566),
        Weighted(f, 0.32410737384983895),
        Weighted(a, 0.3340791343343044)
      )
    ),
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.341808543904923),
        Weighted(f, 0.3241079771296126),
        Weighted(a, 0.3340834789654644)
      )
    ),
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.3418035960540994),
        Weighted(f, 0.3241085804020573),
        Weighted(a, 0.33408782354384337)
      )
    ),
    FiniteDistribution(
      Vector(
        Weighted(f(a), 0.341798648253904),
        Weighted(f, 0.3241091836683291),
        Weighted(a, 0.33409216807776687)
      )
    ),
    FiniteDistribution(
      Vector(
...

Debug this:¶

This is not expected behaviour: one would expect the weight of $f(a)$ to rise. Instead it rises for one step and then starts sinking. Should start with a clean notebook and track this down.

val lp0 = LocalProver(TermState(FiniteDistribution.unif(a, f(a), f), FiniteDistribution(A -> 0.01, B -> 0.99)), hW = 0, klW = 10).noIsles

lp0: LocalProver = LocalProver(
  TermState(
    FiniteDistribution(
      Vector(
        Weighted(a, 0.3333333333333333),
        Weighted(f(a), 0.3333333333333333),
        Weighted(f, 0.3333333333333333)
      )
    ),
    FiniteDistribution(Vector(Weighted(A, 0.01), Weighted(B, 0.99))),
    Vector(),
    FiniteDistribution(Vector()),
    FiniteDistribution(Vector()),
    Empty
  ),
  TermGenParams(
    0.1,
    0.1,
    0.1,
    0.0,
    0.0,
    0.05,
    0.05,
    0.0,
    0.0,
    0.0,
    0.0,
    0.0,
    0.3,
    0.7,
    0.5,
    0.0,
    0.0,
    0.0
  ),
  1.0E-4,
  12 minutes,
  1.01,
  1.0,
...

val gT0 = lp0.expressionEval.flatMap(e => e.generatorIterant(0, 1, 0.000001, e.finalDist).take(100).toListL.map(_.zipWithIndex.filter(_._2 % 15 == 0)) )

gT0: monix.eval.Task[List[(FiniteDistribution[Term], Int)]] = FlatMap(
  Async(<function2>, false, true, true),
  ammonite.$sess.cmd124$Helper$$Lambda$4309/1555064469@cfdaac4
)

val gF0 = gT0.runToFuture

gF0: monix.execution.CancelableFuture[List[(FiniteDistribution[Term], Int)]] = @keyframes fadein { from { opacity: 0; } to { opacity: 1; } }Success(
  List(
    (
      FiniteDistribution(
        Vector(
          Weighted(f(a), 0.3412860700619766),
          Weighted(f, 0.32410031980599935),
          Weighted(a, 0.334613610132024)
        )
      ),
      0
    ),
    (
      FiniteDistribution(
        Vector(
          Weighted(f(a), 0.3339306190134751),
          Weighted(f, 0.3249955986746654),
          Weighted(a, 0.34107378231185953)
        )
      ),
      15
    ),
    (
      FiniteDistribution(
        Vector(
          Weighted(f(a), 0.32669198377935166),
          Weighted(f, 0.3258766646667746),
          Weighted(a, 0.3474313515538737)
        )
      ),
      30
    ),
    (
      FiniteDistribution(
        Vector(
          Weighted(f(a), 0.319576042233069),
          Weighted(f, 0.3267428021220995),
          Weighted(a, 0.35368115564483155)
        )
...

Correction needed¶

One can always reduce Kullback-Liebler by increasing all probabilities. Normalizing only partly acts against this.
The best approach is probably to add total probability equations, at least for initial and final values of terms.