# Aligned Induction

## Lenter

### Sections

Conditional entropy tuple set builder

Conditional entropy fud decomper

### Conditional entropy tuple set builder

The application of the conditional entropy tuple set builder is described in Python.

The conditional entropy tuple set builder parametersBuilderConditionalVars is defined in module AlignmentPracticable.

parametersBuilderConditionalVars ::
Integer -> Integer -> Integer -> Set.Set Variable -> Histogram ->
Maybe (Map.Map (Set.Set Variable) Double)

def parametersBuilderConditionalVars(kmax,omax,qmax,ll,aa):
...


The repa builder is defined in module AlignmentPracticableRepa,

parametersBuilderConditionalVarsRepa ::
Integer -> Integer -> Integer -> Set.Set Variable -> HistoryRepa ->
Maybe (Map.Map (Set.Set Variable) Double)

def parametersBuilderConditionalVarsRepa(kmax,omax,qmax,ll,aa):
...


### Conditional entropy fud decomper

The repa conditional entropy fud decomper is defined in module AlignmentPracticableRepa,

parametersSystemsHistoryRepasDecomperConditionalFmaxRepa ::
Integer -> Integer -> Integer -> System -> Set.Set Variable -> HistoryRepa ->
Maybe (System, DecompFud)

def parametersSystemsHistoryRepasDecomperConditionalFmaxRepa(kmax,omax,fmax,uu,ll,aa):
...
def lenter(ll,aa):
return list(parametersBuilderConditionalVarsRepa(kmax,omax,1,ll,aa).items())
...
def decomp(uu,zz,qq,f):
if len(zz) == 0:
nnr = lenter(ll,aa)
if len(nnr) == 0:
return (uu, decompFudEmpty())
[(kkr,_)] = nnr
ffr = vvff(uu,kkr,f)
uur = uunion(uu,fsys(ffr))
aar = apply(uur,ffr,aa)
aa1 = trim(reduce(uur,fder(ffr)|ll,aar))
zzr = tsgl((stateEmpty(),ffr))
qq[(stateEmpty(),ffr)] = (aar,aa1)
(ffr,nnr,kkr) = (None,None,None)
return decomp(uur,zzr,qq,f+1)
if fmax > 0 and f > fmax:
return (uu,zzdf(zz))
mm = []
for (nn,yy) in treesPlaces(zz):
(rr,ff) = nn[-1]
(bb,bb1) = qq[(rr,ff)]
tt = dom(treesRoots(yy))
for (ss,a) in aall(red(bb1,fder(ff))):
if a > 0 and ss not in tt:
e = a * ent(red(mul(bb1,unit(sset([ss]))),ll))
if e > rounding:
mm.append((e,(nn,ss,bb)))
if len(mm) == 0:
return (uu,zzdf(zz))
mm.sort(key = lambda x: x[0])
(_,(nn,ss,bb)) = mm[-1]
cc = hrhrred(select(uu,ss,bb),vv)
nnc = lenter(ll,cc)
[(kkc,_)] = nnc
ffc = vvff(uu,kkc,f)
uuc = uunion(uu,fsys(ffc))
ccc = apply(uuc,ffc,cc)
cc1 = trim(reduce(uuc,fder(ffc)|ll,ccc))
qq[(ss,ffc)] = (ccc,cc1)
zzc = pathsTree(treesPaths(zz) + [nn+[(ss,ffc)]])
(mm,cc,ffc,nnc,kkc) = (None,None,None,None,None)
return decomp(uuc,zzc,qq,f+1)
if kmax < 0 or omax < 0:
return None
return decomp(uu,emptyTree(),sdict(),1)
...


top