checkpoint
This commit is contained in:
Kacper Marzecki
parent
bc77e1f86b
commit
2ea586c4ad
713
test.exs
713
test.exs
@ -296,83 +296,232 @@ defmodule Tdd do
|
||||
# Check 1: Primary type mutual exclusivity
|
||||
primary_true_predicates =
|
||||
Enum.reduce(assumptions_map, MapSet.new(), fn
|
||||
# A variable like {0, :is_atom} is a primary type predicate
|
||||
{{0, predicate_name}, true}, acc_set -> MapSet.put(acc_set, predicate_name)
|
||||
_otherwise, acc_set -> acc_set
|
||||
end)
|
||||
|
||||
if MapSet.size(primary_true_predicates) > 1 do
|
||||
IO.inspect(assumptions_map, label: "Contradiction: Primary Types")
|
||||
# IO.inspect(assumptions_map, label: "Contradiction: Primary Types")
|
||||
:contradiction
|
||||
else
|
||||
# Check 2: Specific atom value conflicts, e.g. {1, :value, :foo} == true AND {1, :value, :bar} == true
|
||||
atom_value_trues =
|
||||
Enum.reduce(assumptions_map, MapSet.new(), fn
|
||||
{{1, :value, atom_val}, true}, acc_set -> MapSet.put(acc_set, atom_val)
|
||||
_otherwise, acc_set -> acc_set
|
||||
# --- Atom-specific checks ---
|
||||
# Check if any atom-specific predicate (category 1) is asserted as true.
|
||||
has_true_atom_specific_pred =
|
||||
Enum.any?(assumptions_map, fn {var_id, truth_value} ->
|
||||
elem(var_id, 0) == 1 && truth_value == true
|
||||
end)
|
||||
|
||||
if MapSet.size(atom_value_trues) > 1 do
|
||||
IO.inspect(assumptions_map, label: "Contradiction: Atom Values")
|
||||
:contradiction
|
||||
else
|
||||
# Check 3: Tuple size conflicts, e.g. {4, :size, 2} == true AND {4, :size, 3} == true
|
||||
tuple_size_trues =
|
||||
Enum.reduce(assumptions_map, MapSet.new(), fn
|
||||
{{4, :size, size_val}, true}, acc_set -> MapSet.put(acc_set, size_val)
|
||||
_otherwise, acc_set -> acc_set
|
||||
end)
|
||||
# Check if the type is explicitly NOT an atom, or if a different primary type is asserted.
|
||||
is_explicitly_not_atom_or_different_primary =
|
||||
Map.get(assumptions_map, @v_is_atom) == false ||
|
||||
(MapSet.size(primary_true_predicates) == 1 &&
|
||||
!MapSet.member?(primary_true_predicates, :is_atom))
|
||||
|
||||
if MapSet.size(tuple_size_trues) > 1 do
|
||||
cond do
|
||||
has_true_atom_specific_pred && is_explicitly_not_atom_or_different_primary ->
|
||||
# Atom-specific predicate asserted on a confirmed non-atom type.
|
||||
:contradiction
|
||||
else
|
||||
# Check 4: Integer predicate conflicts (New)
|
||||
# Collect all integer constraints assumed to be true
|
||||
# eq_val stores THE value if an :eq constraint is true. nil otherwise.
|
||||
# lt_bound stores the smallest N for which `val < N` is true (upper bound, exclusive). nil if none.
|
||||
# gt_bound stores the largest N for which `val > N` is true (lower bound, exclusive). nil if none.
|
||||
constraints =
|
||||
Enum.reduce(assumptions_map, %{eq_val: nil, lt_b: nil, gt_b: nil}, fn
|
||||
{{2, :eq, n}, true}, acc ->
|
||||
%{acc | eq_val: if(is_nil(acc.eq_val) or acc.eq_val == n, do: n, else: :conflict)}
|
||||
|
||||
{{2, :lt, n}, true}, acc ->
|
||||
%{acc | lt_b: min_opt(acc.lt_b, n)}
|
||||
|
||||
{{2, :gt, n}, true}, acc ->
|
||||
%{acc | gt_b: max_opt(acc.gt_b, n)}
|
||||
|
||||
_otherwise, acc ->
|
||||
acc
|
||||
# Proceed with internal atom value checks if relevant.
|
||||
true ->
|
||||
atom_value_trues =
|
||||
Enum.reduce(assumptions_map, MapSet.new(), fn
|
||||
# An atom value predicate is like {1, :value, :some_atom}
|
||||
{{1, :value, atom_val}, true}, acc_set -> MapSet.put(acc_set, atom_val)
|
||||
_otherwise, acc_set -> acc_set
|
||||
end)
|
||||
|
||||
cond do
|
||||
# Multiple different equality constraints
|
||||
constraints.eq_val == :conflict ->
|
||||
:contradiction
|
||||
if MapSet.size(atom_value_trues) > 1 do
|
||||
# IO.inspect(assumptions_map, label: "Contradiction: Atom Values")
|
||||
:contradiction
|
||||
else
|
||||
# --- Tuple-specific checks ---
|
||||
has_true_tuple_specific_pred =
|
||||
Enum.any?(assumptions_map, fn {var_id, truth_value} ->
|
||||
# Category 4 for tuples
|
||||
elem(var_id, 0) == 4 && truth_value == true
|
||||
end)
|
||||
|
||||
# Check eq_val against lt_b and gt_b
|
||||
is_integer(constraints.eq_val) ->
|
||||
eq_v = constraints.eq_val
|
||||
lt_ok = is_nil(constraints.lt_b) || eq_v < constraints.lt_b
|
||||
gt_ok = is_nil(constraints.gt_b) || eq_v > constraints.gt_b
|
||||
if lt_ok && gt_ok, do: :consistent, else: :contradiction
|
||||
is_explicitly_not_tuple_or_different_primary =
|
||||
Map.get(assumptions_map, @v_is_tuple) == false ||
|
||||
(MapSet.size(primary_true_predicates) == 1 &&
|
||||
!MapSet.member?(primary_true_predicates, :is_tuple))
|
||||
|
||||
# Check lt_b vs gt_b (if no specific eq_val)
|
||||
is_integer(constraints.lt_b) && is_integer(constraints.gt_b) &&
|
||||
constraints.lt_b <= constraints.gt_b + 1 ->
|
||||
# e.g., x < 5 AND x > 4 (no integer) OR x < 5 AND x > 3 (only x=4)
|
||||
# If lt_b <= gt_b + 1, it means there's no integer space or only one possible integer.
|
||||
# If lt_b == gt_b + 1, it implies x must be that one integer. This isn't a contradiction by itself yet.
|
||||
# If lt_b <= gt_b, it's a definite contradiction e.g. x < 5 and x > 5.
|
||||
if constraints.lt_b <= constraints.gt_b, do: :contradiction, else: :consistent
|
||||
cond do
|
||||
has_true_tuple_specific_pred && is_explicitly_not_tuple_or_different_primary ->
|
||||
# Tuple-specific predicate on a confirmed non-tuple type.
|
||||
:contradiction
|
||||
|
||||
# No contradiction found from integer constraints alone
|
||||
true ->
|
||||
:consistent
|
||||
true ->
|
||||
tuple_size_trues =
|
||||
Enum.reduce(assumptions_map, MapSet.new(), fn
|
||||
{{4, :size, size_val}, true}, acc_set -> MapSet.put(acc_set, size_val)
|
||||
_otherwise, acc_set -> acc_set
|
||||
end)
|
||||
|
||||
if MapSet.size(tuple_size_trues) > 1 do
|
||||
:contradiction
|
||||
else
|
||||
# --- Integer predicate checks (REVISED LOGIC from previous iteration) ---
|
||||
has_true_integer_specific_pred =
|
||||
Enum.any?(assumptions_map, fn {var_id, truth_value} ->
|
||||
# Category 2 for integers
|
||||
elem(var_id, 0) == 2 && truth_value == true
|
||||
end)
|
||||
|
||||
is_explicitly_not_integer_or_different_primary =
|
||||
Map.get(assumptions_map, @v_is_integer) == false ||
|
||||
(MapSet.size(primary_true_predicates) == 1 &&
|
||||
!MapSet.member?(primary_true_predicates, :is_integer))
|
||||
|
||||
# This flag indicates if we should even bother with interval logic.
|
||||
# We check if there are integer-specific predicates *or* if the primary type is known to be integer.
|
||||
should_check_integer_logic =
|
||||
Enum.any?(assumptions_map, fn {var_id, _} -> elem(var_id, 0) == 2 end) ||
|
||||
MapSet.member?(primary_true_predicates, :is_integer)
|
||||
|
||||
cond do
|
||||
has_true_integer_specific_pred &&
|
||||
is_explicitly_not_integer_or_different_primary ->
|
||||
# Integer-specific predicate on a confirmed non-integer type.
|
||||
:contradiction
|
||||
|
||||
should_check_integer_logic ->
|
||||
initial_bounds = %{eq_val: nil, min_b: nil, max_b: nil}
|
||||
|
||||
bounds_acc =
|
||||
Enum.reduce(
|
||||
assumptions_map,
|
||||
initial_bounds,
|
||||
fn
|
||||
# Integer predicates are category 2
|
||||
{{2, :eq, n}, true}, acc ->
|
||||
cond do
|
||||
acc.eq_val == :conflict -> acc
|
||||
is_nil(acc.eq_val) -> %{acc | eq_val: n}
|
||||
# Different eq values
|
||||
acc.eq_val != n -> %{acc | eq_val: :conflict}
|
||||
# Same eq value, no change
|
||||
true -> acc
|
||||
end
|
||||
|
||||
# value < n => value <= n-1
|
||||
{{2, :lt, n}, true}, acc ->
|
||||
new_max_b_val = n - 1
|
||||
|
||||
updated_max_b =
|
||||
if is_nil(acc.max_b),
|
||||
do: new_max_b_val,
|
||||
else: min(acc.max_b, new_max_b_val)
|
||||
|
||||
%{acc | max_b: updated_max_b}
|
||||
|
||||
# value > n => value >= n+1
|
||||
{{2, :gt, n}, true}, acc ->
|
||||
new_min_b_val = n + 1
|
||||
|
||||
updated_min_b =
|
||||
if is_nil(acc.min_b),
|
||||
do: new_min_b_val,
|
||||
else: max(acc.min_b, new_min_b_val)
|
||||
|
||||
%{acc | min_b: updated_min_b}
|
||||
|
||||
# value >= n
|
||||
{{2, :lt, n}, false}, acc ->
|
||||
new_min_b_val = n
|
||||
|
||||
updated_min_b =
|
||||
if is_nil(acc.min_b),
|
||||
do: new_min_b_val,
|
||||
else: max(acc.min_b, new_min_b_val)
|
||||
|
||||
%{acc | min_b: updated_min_b}
|
||||
|
||||
# value <= n
|
||||
{{2, :gt, n}, false}, acc ->
|
||||
new_max_b_val = n
|
||||
|
||||
updated_max_b =
|
||||
if is_nil(acc.max_b),
|
||||
do: new_max_b_val,
|
||||
else: min(acc.max_b, new_max_b_val)
|
||||
|
||||
%{acc | max_b: updated_max_b}
|
||||
|
||||
# If is_integer is explicitly false, and we have int predicates, it's a conflict
|
||||
# This is partly covered by the preamble, but good to have in reduction too.
|
||||
# However, this specific check here might be complex to integrate cleanly
|
||||
# with the bounds logic. The preamble should suffice.
|
||||
|
||||
# Non-integer predicates or non-true integer predicates
|
||||
_otherwise, acc ->
|
||||
acc
|
||||
end
|
||||
)
|
||||
|
||||
# Stage 1: Initial bounds from <, >, <=, >=
|
||||
derived_min_b = bounds_acc.min_b
|
||||
derived_max_b = bounds_acc.max_b
|
||||
|
||||
# Stage 2: Check for immediate conflict from <, >, <=, >=
|
||||
if is_integer(derived_min_b) && is_integer(derived_max_b) &&
|
||||
derived_min_b > derived_max_b do
|
||||
# IO.inspect({assumptions_map, bounds_acc, derived_min_b, derived_max_b}, label: "CAC Int: Initial min > max")
|
||||
:contradiction
|
||||
else
|
||||
# Stage 3: Incorporate equality constraint
|
||||
cond do
|
||||
# e.g. eq(5) and eq(7)
|
||||
bounds_acc.eq_val == :conflict ->
|
||||
# IO.inspect({assumptions_map, bounds_acc}, label: "CAC Int: eq_val conflict")
|
||||
:contradiction
|
||||
|
||||
is_integer(bounds_acc.eq_val) ->
|
||||
eq_v = bounds_acc.eq_val
|
||||
|
||||
# The value must be eq_v. Check if eq_v fits in the derived_min_b/derived_max_b interval.
|
||||
min_ok = is_nil(derived_min_b) || eq_v >= derived_min_b
|
||||
max_ok = is_nil(derived_max_b) || eq_v <= derived_max_b
|
||||
|
||||
if min_ok && max_ok do
|
||||
# IO.inspect({assumptions_map, bounds_acc, eq_v, derived_min_b, derived_max_b}, label: "CAC Int: eq consistent with interval")
|
||||
:consistent
|
||||
else
|
||||
# IO.inspect({assumptions_map, bounds_acc, eq_v, derived_min_b, derived_max_b}, label: "CAC Int: eq CONTRADICTS interval")
|
||||
:contradiction
|
||||
end
|
||||
|
||||
# No equality constraint, or no conflict from it. The initial interval check (derived_min_b > derived_max_b) suffices.
|
||||
true ->
|
||||
# IO.inspect({assumptions_map, bounds_acc, derived_min_b, derived_max_b}, label: "CAC Int: consistent (no eq or eq compatible)")
|
||||
:consistent
|
||||
end
|
||||
end
|
||||
|
||||
# No integer contradictions to check
|
||||
true ->
|
||||
:consistent
|
||||
end
|
||||
|
||||
# End integer checks
|
||||
end
|
||||
|
||||
# End tuple size checks
|
||||
end
|
||||
|
||||
# End tuple preamble
|
||||
end
|
||||
end
|
||||
|
||||
# End atom value checks
|
||||
end
|
||||
|
||||
# End atom preamble
|
||||
end
|
||||
|> IO.inspect(
|
||||
label: "check_assumptions_consistency END assumptions_map = #{inspect(assumptions_map)}"
|
||||
)
|
||||
end
|
||||
|
||||
# Helper for min, treating nil as infinity
|
||||
@ -387,59 +536,108 @@ defmodule Tdd do
|
||||
# --- Semantic Simplification (Memoized) ---
|
||||
defp simplify_with_constraints(tdd_id, assumptions_map) do
|
||||
state = get_state()
|
||||
sorted_assumptions_list = Enum.sort_by(assumptions_map, fn {var, _val} -> var end)
|
||||
# Sort assumptions for cache key consistency
|
||||
# Using Map.to_list and then sorting is more robust than Enum.sort_by if keys can be complex
|
||||
sorted_assumptions_list = Enum.sort(Map.to_list(assumptions_map))
|
||||
cache_key = {:simplify_constr, tdd_id, sorted_assumptions_list}
|
||||
|
||||
# Order of checks is critical:
|
||||
# 1. Is the current set of assumptions inherently contradictory? If so, this path is dead.
|
||||
# 2. Is the TDD itself terminal? (Assumptions are consistent at this point)
|
||||
if check_assumptions_consistency(assumptions_map) == :contradiction do
|
||||
# IO.inspect({tdd_id, assumptions_map}, label: "SimplifyContradiction (Early Exit)")
|
||||
# No need to cache here if it's based purely on assumptions,
|
||||
# but if tdd_id was involved, caching the result for {tdd_id, assumptions} is good.
|
||||
# Let's cache it for safety, as tdd_id is part of cache_key.
|
||||
update_state(%{op_cache: Map.put(state.op_cache, cache_key, @false_node_id)})
|
||||
# 1. Check if the current assumptions_map itself is contradictory
|
||||
# This initial check is crucial.
|
||||
current_consistency = check_assumptions_consistency(assumptions_map)
|
||||
|
||||
if current_consistency == :contradiction do
|
||||
# update_state(%{op_cache: Map.put(state.op_cache, cache_key, @false_node_id)}) # Cache if desired
|
||||
@false_node_id
|
||||
else
|
||||
# 3. Cache lookup
|
||||
# 2. Handle terminal nodes
|
||||
if is_terminal_id(tdd_id) do
|
||||
# IO.inspect({tdd_id, assumptions_map}, label: "SimplifyTerminal")
|
||||
# Terminals are not affected by further assumptions if not contradictory
|
||||
# Terminals are final, assumptions (if consistent) don't change them
|
||||
tdd_id
|
||||
else
|
||||
# 3. Cache lookup for non-terminal nodes
|
||||
if Map.has_key?(state.op_cache, cache_key) do
|
||||
# IO.inspect({tdd_id, assumptions_map}, label: "SimplifyFromCache")
|
||||
state.op_cache[cache_key]
|
||||
else
|
||||
# 4. Not contradictory, not terminal, not in cache: Process the node
|
||||
{var, y, n, d} = get_node_details(tdd_id)
|
||||
# IO.inspect({tdd_id, assumptions_map, var}, label: "SimplifyProcessingNode")
|
||||
|
||||
# 4. Determine how to proceed based on 'var' and 'assumptions_map'
|
||||
result_id =
|
||||
case Map.get(assumptions_map, var) do
|
||||
# 'var' is explicitly assumed true
|
||||
true ->
|
||||
simplify_with_constraints(y, assumptions_map)
|
||||
|
||||
# 'var' is explicitly assumed false
|
||||
false ->
|
||||
simplify_with_constraints(n, assumptions_map)
|
||||
|
||||
# 'var' is explicitly assumed don't care
|
||||
:dc ->
|
||||
simplify_with_constraints(d, assumptions_map)
|
||||
|
||||
# 'var' is NOT explicitly in assumptions_map. Check for implied truth value.
|
||||
nil ->
|
||||
simplified_y = simplify_with_constraints(y, Map.put(assumptions_map, var, true))
|
||||
simplified_n = simplify_with_constraints(n, Map.put(assumptions_map, var, false))
|
||||
simplified_d = simplify_with_constraints(d, Map.put(assumptions_map, var, :dc))
|
||||
make_node_raw(var, simplified_y, simplified_n, simplified_d)
|
||||
# If (assumptions_map + var=false) is a contradiction, then var MUST be true.
|
||||
implies_var_true =
|
||||
check_assumptions_consistency(Map.put(assumptions_map, var, false)) ==
|
||||
:contradiction
|
||||
|
||||
# If (assumptions_map + var=true) is a contradiction, then var MUST be false.
|
||||
implies_var_false =
|
||||
check_assumptions_consistency(Map.put(assumptions_map, var, true)) ==
|
||||
:contradiction
|
||||
|
||||
# Note: We don't check for implies_var_dc here, as that's more complex.
|
||||
# The original recursion handles the DC case exploration.
|
||||
|
||||
IO.inspect(
|
||||
%{
|
||||
tdd_id: tdd_id,
|
||||
var: var,
|
||||
assumptions: assumptions_map,
|
||||
implies_var_true: implies_var_true,
|
||||
implies_var_false: implies_var_false
|
||||
},
|
||||
label: "Simplify NIL branch"
|
||||
)
|
||||
|
||||
cond do
|
||||
implies_var_true && implies_var_false ->
|
||||
# This means assumptions_map itself is contradictory.
|
||||
# This should ideally be caught by the check at the very top of simplify_with_constraints.
|
||||
# If reached, it implies an issue or a very complex interaction. Safest is False.
|
||||
# IO.inspect({assumptions_map, var}, label: "Simplify: Contradiction from implies_var_true/false")
|
||||
@false_node_id
|
||||
|
||||
implies_var_true ->
|
||||
# Var is implied true by other assumptions. Follow the 'yes' branch.
|
||||
# Pass the original 'assumptions_map' because 'var's truth is derived, not added.
|
||||
simplify_with_constraints(y, assumptions_map)
|
||||
|
||||
implies_var_false ->
|
||||
# Var is implied false. Follow the 'no' branch.
|
||||
simplify_with_constraints(n, assumptions_map)
|
||||
|
||||
true ->
|
||||
# Var's value is not forced by current assumptions. Recurse normally.
|
||||
simplified_y =
|
||||
simplify_with_constraints(y, Map.put(assumptions_map, var, true))
|
||||
|
||||
simplified_n =
|
||||
simplify_with_constraints(n, Map.put(assumptions_map, var, false))
|
||||
|
||||
simplified_d =
|
||||
simplify_with_constraints(d, Map.put(assumptions_map, var, :dc))
|
||||
|
||||
make_node_raw(var, simplified_y, simplified_n, simplified_d)
|
||||
end
|
||||
end
|
||||
|
||||
# IO.inspect({tdd_id, assumptions_map, result_id}, label: "SimplifyExitComputed")
|
||||
update_state(%{op_cache: Map.put(state.op_cache, cache_key, result_id)})
|
||||
result_id
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
# End of nested cond/if
|
||||
end
|
||||
|
||||
# --- Public Node Creation (Used by Type Constructors) ---
|
||||
@ -684,10 +882,42 @@ defmodule Tdd do
|
||||
true ->
|
||||
# A <: B <=> A ∩ (¬B) == ∅
|
||||
# All operations (intersect, negate) now produce semantically simplified results.
|
||||
IO.puts("\n--- is_subtype debug ---")
|
||||
|
||||
IO.inspect(sub_type_id,
|
||||
label: "is_subtype: sub_type_id (#{inspect(Tdd.get_node_details(sub_type_id))})"
|
||||
)
|
||||
|
||||
IO.inspect(super_type_id,
|
||||
label: "is_subtype: super_type_id (#{inspect(Tdd.get_node_details(super_type_id))})"
|
||||
)
|
||||
|
||||
# Tdd.print_tdd(sub_type_id)
|
||||
# Tdd.print_tdd(super_type_id)
|
||||
|
||||
negated_super = negate(super_type_id)
|
||||
|
||||
IO.inspect(negated_super,
|
||||
label: "is_subtype: negated_super_id (#{inspect(Tdd.get_node_details(negated_super))})"
|
||||
)
|
||||
|
||||
# IO.puts("Structure of negated_super:")
|
||||
# Tdd.print_tdd(negated_super)
|
||||
|
||||
intersection_result = intersect(sub_type_id, negated_super)
|
||||
# Check against canonical false
|
||||
intersection_result == @false_node_id
|
||||
|
||||
IO.inspect(intersection_result,
|
||||
label:
|
||||
"is_subtype: intersection_result_id (#{inspect(Tdd.get_node_details(intersection_result))})"
|
||||
)
|
||||
|
||||
# IO.puts("Structure of intersection_result:")
|
||||
# Tdd.print_tdd(intersection_result)
|
||||
|
||||
result = intersection_result == @false_node_id
|
||||
IO.inspect(result, label: "is_subtype: final result")
|
||||
IO.puts("--- end is_subtype debug ---\n")
|
||||
result
|
||||
end
|
||||
end
|
||||
|
||||
@ -1069,14 +1299,315 @@ end
|
||||
# test_all.()
|
||||
# IntegerTests.run(test)
|
||||
|
||||
# x < 3
|
||||
tdd_int_lt_3 = Tdd.type_int_lt(3)
|
||||
# x > 10
|
||||
tdd_int_gt_10 = Tdd.type_int_gt(10)
|
||||
union_disjoint_ranges = Tdd.sum(tdd_int_lt_3, tdd_int_gt_10)
|
||||
tdd_int_gt_3 = Tdd.type_int_gt(3)
|
||||
test.("int_gt_10 <: int_gt_3", true, Tdd.is_subtype(tdd_int_gt_10, tdd_int_gt_3))
|
||||
|
||||
test.(
|
||||
"int_eq(12) <: (int < 3 | int > 10)",
|
||||
true,
|
||||
Tdd.is_subtype(Tdd.type_int_eq(12), union_disjoint_ranges)
|
||||
)
|
||||
# output:
|
||||
#
|
||||
# TDD system initialized.
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_atom},
|
||||
# tdd_id: 3,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :foo} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :foo} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {1, :value, :foo},
|
||||
# tdd_id: 2,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_atom} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :foo} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :foo} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :foo} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_atom},
|
||||
# tdd_id: 5,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :bar} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :bar} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {1, :value, :bar},
|
||||
# tdd_id: 4,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_atom} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :bar} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :bar} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :bar} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_atom},
|
||||
# tdd_id: 6,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_tuple},
|
||||
# tdd_id: 8,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 0} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 0} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {4, :size, 0},
|
||||
# tdd_id: 7,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_tuple} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 0} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 0} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 0} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_atom},
|
||||
# tdd_id: 10,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :baz} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :baz} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {1, :value, :baz},
|
||||
# tdd_id: 9,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_atom} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :baz} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :baz} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => true, {1, :value, :baz} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_atom} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_tuple},
|
||||
# tdd_id: 11,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_tuple},
|
||||
# tdd_id: 13,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 2} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 2} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {4, :size, 2},
|
||||
# tdd_id: 12,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_tuple} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 2} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 2} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => true, {4, :size, 2} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_tuple} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_integer},
|
||||
# tdd_id: 15,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 10} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 10} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 10},
|
||||
# tdd_id: 14,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_integer} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 10} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 10} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 10} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_integer},
|
||||
# tdd_id: 17,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 3},
|
||||
# tdd_id: 16,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_integer} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => :dc}: :consistent
|
||||
#
|
||||
# --- is_subtype debug ---
|
||||
# is_subtype: sub_type_id ({{0, :is_integer}, 14, 0, 0}): 15
|
||||
# is_subtype: super_type_id ({{0, :is_integer}, 16, 0, 0}): 17
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{2, :gt, 3} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 3},
|
||||
# tdd_id: 18,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{2, :gt, 3} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{2, :gt, 3} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_integer},
|
||||
# tdd_id: 19,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 3},
|
||||
# tdd_id: 18,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_integer} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => :dc}: :consistent
|
||||
# is_subtype: negated_super_id ({{0, :is_integer}, 18, 1, 1}): 19
|
||||
# check_assumptions_consistency END assumptions_map = %{}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {0, :is_integer},
|
||||
# tdd_id: 21,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 3},
|
||||
# tdd_id: 20,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_integer} => true}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false, {2, :gt, 10} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false, {2, :gt, 10} => true}: :contradiction
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 10},
|
||||
# tdd_id: 14,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: true,
|
||||
# assumptions: %{{0, :is_integer} => true, {2, :gt, 3} => false}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc, {2, :gt, 10} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc, {2, :gt, 10} => true}: :consistent
|
||||
# Simplify NIL branch: %{
|
||||
# var: {2, :gt, 10},
|
||||
# tdd_id: 14,
|
||||
# implies_var_true: false,
|
||||
# implies_var_false: false,
|
||||
# assumptions: %{{0, :is_integer} => true, {2, :gt, 3} => :dc}
|
||||
# }
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc, {2, :gt, 10} => true}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc, {2, :gt, 10} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => true, {2, :gt, 3} => :dc, {2, :gt, 10} => :dc}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => false}: :consistent
|
||||
# check_assumptions_consistency END assumptions_map = %{{0, :is_integer} => :dc}: :consistent
|
||||
# is_subtype: intersection_result_id ({{0, :is_integer}, 22, 0, 0}): 23
|
||||
# is_subtype: final result: false
|
||||
# --- end is_subtype debug ---
|
||||
#
|
||||
# int_gt_10 <: int_gt_3 (Expected: true) -> Result: false - FAILED
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user