Dedukčního strom je strukturovaná reprezentace řešení úlohy.

Řešení úlohy je rozděleno na posloupnost jednoduchých kroků. Pořadí a návaznosti jednotlivých kroků definuje dedukčního strom, kde kroky jsou uzly stromu a vrchol stromu je konečný výsledek.

Podrobnosti a příklady, jak vytvořit dedukční strom zde

Příklad - slepičí hádanka

Predikáty

Predikáty umožňují formalní zápis situačního modelu úlohy.

Odvozovací pravidla

Porovnávání

Porovnání - o kolik je větší / menší?

Porovnání podílem - kolikrát je větší / menší?

Porovnání rozdílem - kolik je rozdíl?

Porovnávání - část z celku

Porovnávání - poměry část ku časti

Porovnávání - úhly

Stav a změna stavu

Rozdělování

Spojování

Převod jednotek

Nejmenší společný násobek

Největší společný dělitel

Posloupnosti

Aritmetická

Kvadratická

Geometrická

Základní odvozovací vzory

Procenta

Výpočet procentní části

Výpočet základu

Výpočet procent

Úměrnosti

Přímá úměrnost

Nepřímá úměrnost

Kombinovaná přímá a nepřímá úměrnost

Porovnávání

Porovnávání s absolutním rozdílem

Porovnání s relativním rozdílem

Porovnání s absolutním a relativním rozdílem

Porovnání části k celku

Měřítko

Tělesa

Kvádr

Válec

Trojboký hranol

Jak je to uděláno?

Můžete použít jako javascript module.

<script type="module">
import {cont, inferenceRule} from "https://www.cermatdata.cz/components/math.js";

const result = inferenceRule(
  cont("půjčka", 300, "Kč"),
  inferenceRule(
    cont("úrok", 20, "%"),
    cont("půjčka", 100, "%"),
    { kind: 'ratio' }
  )
);

//Výsledek: úrok = 60 Kč
console.log(`Výsledek: ${result.agent} = ${result.quantity} ${result.entity}`)

</script>

Dedukční strom

Obecný postup vytvoření dedukčního stromu ze zadání úlohy

• zadání úlohy je potřeba převést (text comprehension) na sadu predikátů (formalizované pravdivé tvrzení)
• použít odvozovací pravidla (inference rules)
  • vstupem - seznam predikátů, resp. předpokladů (premises)
  • výstupem - jeden predikát
• výsledek úlohy získáme průchodem stromu do hloubky (post-order), tj. aplikujeme odvozovací pravidla až poté, co známe všechny vstupy (premises)

Konkrétní příklad řešení pro zadání úlohy

import { comp, compRatio, nthPart, rate, ratios, sum } from "../../components/math.js";
import { axiomInput, deduce, last } from "../../utils/deduce-utils.js";

export function kytice() {
  //agent names and entities
  const kyticeAgent = "kytice";
  const chryzatemaAgent = "chryzantéma";
  const ruzeAgent = "růže";
  const staticAgent = "statice";

  const kusEntity = "kus";
  const entity = "cena";

  //axioms
  const rozdilRuze = axiomInput(comp(ruzeAgent, staticAgent, 2, kusEntity), 1);
  const RtoS = axiomInput(compRatio(ruzeAgent, staticAgent, 5 / 4), 2);
  const CHxS = axiomInput(ratios(kyticeAgent, [chryzatemaAgent, staticAgent], [3, 2]), 3);
  const ruzeRate = axiomInput(rate(chryzatemaAgent, 54, entity, kusEntity), 4)
  const chryzantemaRate = axiomInput(rate(chryzatemaAgent, 40, entity, kusEntity), 5)
  const staticeRate = axiomInput(rate(chryzatemaAgent, 35, entity, kusEntity), 6)

  //deduction
  const statice = deduce(
    rozdilRuze,
    RtoS
  )
  const chryzantem = deduce(
    last(statice),
    CHxS,
    nthPart(chryzatemaAgent)
  )
  const ruze = deduce(
    statice,
    rozdilRuze
  )

  return {
    deductionTree: deduce(
      deduce(ruze, ruzeRate),
      deduce(last(statice), staticeRate),
      deduce(chryzantem, chryzantemaRate),
      sum(kyticeAgent, [ruzeAgent, chryzatemaAgent, staticAgent], entity, entity)
    )
  }
}

Další příklady jsou zde

API

Predikáty (predicates)

export declare type Predicate = Container | Comparison | RatioComparison | Transfer | Rate | Combine | PartWholeRatio | PartToPartRatio | ComparisonDiff | CommonSense | GCD | LCD;
export declare function cont(agent: string, quantity: number, entity: string): Container;
export declare function comp(agentA: string, agentB: string, quantity: number, entity: string): Comparison;
export declare function compRatio(agentA: string, agentB: string, quantity: number, entity: string): RatioComparison;
export declare function compDiff(agentMinuend: string, agentSubtrahend: string, quantity: number, entity: string): ComparisonDiff;
export declare function ratio(whole: EntityMatcher, part: EntityMatcher, ratio: number): PartWholeRatio;
export declare function ratios(whole: EntityMatcher, parts: EntityMatcher[], ratios: number[]): PartToPartRatio;
export declare function sum(wholeAgent: string, partAgents: string[], wholeEntity: string, partEntity: string): Combine;
export declare function gcd(agent: string, entity: string): GCD;
export declare function lcd(agent: string, entity: string): LCD;
export declare function rate(agent: string, quantity: number, entity: string, entityBase: string): Rate;
export declare function commonSense(description: string): CommonSense;

Odvozovací pravidla (inference rules)

export declare function inferenceRule(a: Predicate | Container[], b: Predicate, c?: {
    kind: 'ratio' | 'comp-ratio' | 'rate' | "comp-diff" | 'comp-part-eq';
})

Inspirováno prací MathGAP.