more logics and an erratum for Zadeh.

There is quite a lot of interest in logics lately so I added the important Lukasiwicz Logic and the equally interesting Kleene/Dienes logic to my compendium.
Both of these are related to Zadeh logic being continuously valued.
At the same time I discovered - well, Claude did - a small inconsistency in my Zadeh logic where I preferred a Kleene/Dienes implementation for imp() over Zadeh's original (this is common), so I changed it to Zadeh's original, with comment. That was not a bug perse, but needed the change to keep it in line with the publication.
This time I used AI, Claude and DeepSeek to verify both theory and implementation.

LukasiwiczLogic:

Code: Pascal [Select][+]

unit LukasiwiczLogic;
{
  Thaddy de Koning, (c) 2021-2025. Creative commons V3.}
}
{$mode objfpc}{$H+}
{$R-}{$Q-}// No range or overflow checks for performance
 
interface
uses 
  sysutils;
 
type
  { Łukasiewicz truth values in [0,1] }
  TLukasiewiczValue = single;
  
  { Basic Łukasiewicz operations }
  function LukNot(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukAnd(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukOr(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  {Note: default conform theory, but two common alternatives as comments below }
  function LukXor(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukImplies(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukEquiv(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  
  { Operators AND/OR/NOT/XOR }
  operator not(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
  operator and(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  operator or(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  {Note: default conform theory, but two common alternatives as comments below }
  operator xor(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  
  { Additional Łukasiewicz operations }
  function LukStrongConjunction(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukStrongDisjunction(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukDelta(const A: TLukasiewiczValue): TLukasiewiczValue; inline; { Delta operator }
  function LukNabla(const A: TLukasiewiczValue): TLukasiewiczValue; inline; { Nabla operator }
  
  { Łukasiewicz T-norm and T-conorm }
  function LukTNorm(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  function LukTConorm(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
  
  { Threshold functions }
  function LukIsTrue(const A: TLukasiewiczValue; const Threshold: TLukasiewiczValue = 1.0): Boolean; inline;
  function LukIsFalse(const A: TLukasiewiczValue; const Threshold: TLukasiewiczValue = 0.0): Boolean; inline;
  
  { Aggregation operators }
  function LukWeightedAverage(const Values: array of TLukasiewiczValue; 
    const Weights: array of TLukasiewiczValue): TLukasiewiczValue;
  function LukGeneralizedAnd(const Values: array of TLukasiewiczValue): TLukasiewiczValue;
  function LukGeneralizedOr(const Values: array of TLukasiewiczValue): TLukasiewiczValue;
 
implementation
 
uses
  Math;
 
{ Łukasiewicz Negation: ¬A = 1 - A }
function LukNot(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := 1.0 - A;
end;
 
{ Łukasiewicz Conjunction: A ⊗ B = max(0, A + B - 1) }
function LukAnd(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Max(0.0, A + B - 1.0);
end;
 
{ Łukasiewicz Disjunction: A ⊕ B = min(1, A + B) }
function LukOr(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Min(1.0, A + B);
end;
 
{ Łukasiewicz Implication: A → B = min(1, 1 - A + B) }
function LukImplies(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Min(1.0, 1.0 - A + B);
end;
 
{ Łukasiewicz Equivalence: A ↔ B = 1 - |A - B| }
function LukEquiv(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := 1.0 - Abs(A - B);
end;
 
{ Łukasiewicz XOR - Three common definitions }
function LukXor(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  { Definition 1: A ⊕ B = max(min(A, 1-B), min(1-A, B)) 
     This is Łukasiewicz interpretation of exclusive or }
  Result := Max(Min(A, 1.0 - B), Min(1.0 - A, B));
  
  { Alternative definitions (comment out the above and uncomment one below): }
  
  { Definition 2: A ⊕ B = |A - B| }
  // Result := Abs(A - B);
  
  { Definition 3: A ⊕ B = min(max(A, B), max(1-A, 1-B)) - Standard fuzzy XOR }
  // Result := Min(Max(A, B), Max(1.0 - A, 1.0 - B));
end;
 
{ Operators }
operator not(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := 1.0 - A;
end;
 
operator and(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Max(0.0, A + B - 1.0);
end;
 
operator or(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Min(1.0, A + B);
end;
 
operator xor(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  { Using Definition 1 for the operator }
  Result := Max(Min(A, 1.0 - B), Min(1.0 - A, B));
end;
 
{ Strong Conjunction: A ⊙ B = max(0, A + B - 1) (same as ∧ in Łukasiewicz) }
function LukStrongConjunction(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Max(0.0, A + B - 1.0);
end;
 
{ Strong Disjunction: A ⊞ B = min(1, A + B) (same as ∨ in Łukasiewicz) }
function LukStrongDisjunction(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Min(1.0, A + B);
end;
 
{ Delta operator: ΔA = 1 if A = 1, 0 otherwise }
function LukDelta(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  if A = 1.0 then
    Result := 1.0
  else
    Result := 0.0;
end;
 
{ Nabla operator: ∇A = 1 if A > 0, 0 otherwise }
function LukNabla(const A: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  { Use Sign function for faster check }
  if Sign(A) > 0 then
    Result := 1.0
  else
    Result := 0.0;
end;
 
{ T-norm: Łukasiewicz T-norm (same as conjunction) }
function LukTNorm(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Max(0.0, A + B - 1.0);
end;
 
{ T-conorm: Łukasiewicz T-conorm (same as disjunction) }
function LukTConorm(const A, B: TLukasiewiczValue): TLukasiewiczValue; inline;
begin
  Result := Min(1.0, A + B);
end;
 
{ Check if value is considered true (>= threshold) }
function LukIsTrue(const A: TLukasiewiczValue; const Threshold: TLukasiewiczValue = 1.0): Boolean; inline;
begin
  Result := A >= Threshold;
end;
 
{ Check if value is considered false (<= threshold) }
function LukIsFalse(const A: TLukasiewiczValue; const Threshold: TLukasiewiczValue = 0.0): Boolean; inline;
begin
  Result := A <= Threshold;
end;
 
{ Weighted average aggregation }
function LukWeightedAverage(const Values: array of TLukasiewiczValue; 
  const Weights: array of TLukasiewiczValue): TLukasiewiczValue;
var
  i: Integer;
  sumValues, sumWeights: TLukasiewiczValue;
begin
  if Length(Values) = 0 then 
    Exit(0.5); { Default middle value }
   
  if Length(Weights) <> Length(Values) then
    raise Exception.Create('Number of weights must match number of values');
  
  sumValues := 0.0;
  sumWeights := 0.0;
  
  for i := 0 to High(Values) do
  begin
    sumValues := sumValues + Values[i] * Weights[i];
    sumWeights := sumWeights + Weights[i];
  end;
  
  if sumWeights = 0 then
    Result := 0.5
  else
    Result := sumValues / sumWeights;
end;
 
{ Generalized conjunction (minimum for all values) }
function LukGeneralizedAnd(const Values: array of TLukasiewiczValue): TLukasiewiczValue;
var
  i: Integer;
begin
  if Length(Values) = 0 then 
    Exit(1.0); { Empty conjunction is true }
  
  Result := Values[0];
  for i := 1 to High(Values) do
    Result := Max(0.0, Result + Values[i] - 1.0);
end;
 
{ Generalized disjunction (maximum for all values) }
function LukGeneralizedOr(const Values: array of TLukasiewiczValue): TLukasiewiczValue;
var
  i: Integer;
begin
  if Length(Values) = 0 then 
    Exit(0.0); { Empty disjunction is false }
  
  Result := Values[0];
  for i := 1 to High(Values) do
    Result := Min(1.0, Result + Values[i]);
end;
 
end.

Demo for the above:

Code: Pascal [Select][+]

program LukasiewiczDemo;
 
{$mode objfpc}{$H+}
 
uses
  LukasiwiczLogic, SysUtils;
 
procedure DemonstrateBasicOperations;
var
  A, B: TLukasiewiczValue;
begin
  WriteLn('=== Łukasiewicz Logic Demo ===');
  WriteLn;
  
  A := 0.7;
  B := 0.4;
  
  WriteLn(Format('A = %.1f, B = %.1f', [A, B]));
  WriteLn(Format('¬A = %.1f', [LukNot(A)]));
  WriteLn(Format('A ∧ B = %.1f', [LukAnd(A, B)]));
  WriteLn(Format('A ∨ B = %.1f', [LukOr(A, B)]));
  WriteLn(Format('A → B = %.1f', [LukImplies(A, B)]));
  WriteLn(Format('A ↔ B = %.1f', [LukEquiv(A, B)]));
  WriteLn;
  
  { Compare with Boolean logic boundaries }
  WriteLn('=== Boundary Cases ===');
  WriteLn(Format('LukAnd(1.0, 1.0) = %.1f (like Boolean AND)', [LukAnd(1.0, 1.0)]));
  WriteLn(Format('LukOr(0.0, 0.0) = %.1f (like Boolean OR)', [LukOr(0.0, 0.0)]));
  WriteLn(Format('LukNot(1.0) = %.1f (like Boolean NOT)', [LukNot(1.0)]));
end;
 
procedure DemonstrateProperties;
var
  A, B, C: TLukasiewiczValue;
begin
  WriteLn;
  WriteLn('=== Key Łukasiewicz Properties ===');
  
  A := 0.6;
  B := 0.3;
  C := 0.8;
  
  { Law of excluded middle: A ∨ ¬A = 1 }
  WriteLn(Format('Law of excluded middle: %.1f ∨ ¬%.1f = %.1f', 
    [A, A, LukOr(A, LukNot(A))]));
  
  { Law of non-contradiction: A ∧ ¬A = 0 }
  WriteLn(Format('Law of non-contradiction: %.1f ∧ ¬%.1f = %.1f', 
    [A, A, LukAnd(A, LukNot(A))]));
  
  { De Morgan's laws }
  WriteLn(Format('De Morgan 1: ¬(%.1f ∧ %.1f) = %.1f, ¬%.1f ∨ ¬%.1f = %.1f', 
    [A, B, LukNot(LukAnd(A, B)), A, B, LukOr(LukNot(A), LukNot(B))]));
  
  WriteLn(Format('De Morgan 2: ¬(%.1f ∨ %.1f) = %.1f, ¬%.1f ∧ ¬%.1f = %.1f', 
    [A, B, LukNot(LukOr(A, B)), A, B, LukAnd(LukNot(A), LukNot(B))]));
end;
 
procedure DemonstrateAggregation;
var
  values: array[0..2] of TLukasiewiczValue;
  weights: array[0..2] of Single;
begin
  WriteLn;
  WriteLn('=== Aggregation Operators ===');
  
  values[0] := 0.8;
  values[1] := 0.4;
  values[2] := 0.6;
  
  weights[0] := 0.5;
  weights[1] := 0.3;
  weights[2] := 0.2;
  
  WriteLn(Format('Weighted average: %.3f', 
    [LukWeightedAverage(values, weights)]));
  WriteLn(Format('Generalized AND: %.1f', 
    [LukGeneralizedAnd(values)]));
  WriteLn(Format('Generalized OR: %.1f', 
    [LukGeneralizedOr(values)]));
end;
 
begin
  DemonstrateBasicOperations;
  DemonstrateProperties;
  DemonstrateAggregation;
  
  WriteLn;
  WriteLn('Press Enter to exit...');
  ReadLn;
end.

Kleene-Dienes:

Code: Pascal [Select][+]

program kleenedieneslogic;
{$mode objfpc}{$notes off}
{ Kleene-Dienes fuzzy logic operators
  
  Key differences from Zadeh logic:
  - AND uses algebraic product: a * b
  - OR uses algebraic sum: a + b - a*b
  - NOT remains the same: 1 - a
  - XOR derived from the above
  
  Named after Stephen Cole Kleene and Jan Dienes.
  
  Thaddy de Koning, (c) 2021-2025. Creative commons V3.}
type
  { Fuzz is a double in the inclusive range 0..1
    The programmer is responsible for valid input.
    (You can use EnsureRange from the math unit.) }
  Fuzz = type double;
 
{ the basic logic }
 
  { AND is defined as algebraic product a * b }
  operator and (const a,b:Fuzz):Fuzz;inline;
  begin
    Result := a * b
  end;
 
  { OR is defined as algebraic sum a + b - a*b }
  operator or (const a,b:Fuzz):Fuzz;inline;
  begin
    Result := a + b - a * b
  end;
 
  { NOT is the inverse, same as Zadeh }
  operator not (const a:Fuzz):Fuzz;inline;
  begin
    Result := 1 - a
  end;
 
  { XOR derived from OR and AND: (a OR b) AND NOT(a AND b) 
    Which expands to: a + b - 2*a*b }
  operator xor (const a,b:Fuzz):Fuzz;inline;
  begin
    Result := a + b - 2 * a * b
  end;
 
{ derived logic as functions }
 
  { IMP - Kleene-Dienes implication: NOT a OR b = 1 - a + a*b }
  function imp(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := (not a) or b
  end;
 
  { NAND }
  function nand(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a and b)
  end;
 
  { NOR }
  function nor(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a or b)
  end;
 
  { NXR (XNOR) }
  function nxr(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a xor b)
  end;
 
  { Inhibition: a AND NOT b }
  function inhibition(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := a and (not b)
  end;
 
begin
end.

Corrected Zadeh for Imp():

Code: Pascal [Select][+]

program zadehlogic;
{$mode objfpc}{$notes off}
{ Zadeh's standard fuzzy logic operators
 See:
   https://commons.wikimedia.org/wiki/Fuzzy_operator
 
 Don't let your eyes fool you, these are not integer or boolean
 calculations, but floating point calculations!.
 
 Enjoy,
 
 Thaddy de Koning, (c) 2021. Creatve commons V3.}
type
  { Fuzz is a double in the inclusive range 0..1
    The programmer is responsible for valid input.
    (You can use EnsureRange from the math unit.) }
  Fuzz = type double;  
 
{ helpers }  
  function min(const a,b:Fuzz):Fuzz;inline;
  begin    
    if a > b then result := b else result := a;
  end;
 
  function max(const a,b:Fuzz):Fuzz;inline;
  begin    
    if b > a then result := b else result := a;
  end;
 
{ the basic logic }
 
  { AND is defined as min(a, b) in standard fuzzy logic }
  operator and (const a,b:Fuzz):Fuzz;inline;
  begin
    Result:=min(a,b);
  end;
 
  { OR is defined as max(a,b) in standard fuzzy logic }
  operator or (const a,b:Fuzz):Fuzz;inline;
  begin
    Result:=max(a, b);
  end;
 
  { NOT is simply the inverse, given a range of 0..1. Comparable to Boolean}
  operator not (const a:Fuzz):Fuzz;inline;
  begin
    result := 1 - a;
  end;
 
  { XOR. See AND how this reflects: the bias to either a or b gets amplified  }
  operator xor (const a,b:Fuzz):Fuzz;inline;
  begin
    result := a + b - 2 * (a and b);
  end;
 
 { not overloaded logic as functions: all can be derived from the above four }
 
  { IMP }
  function imp(const a,b:Fuzz):Fuzz;inline;
  begin
    // Result := not (a and not b) // Kleene-Dienes implication
    Result := max(1-a, min(a,b));  // Zadeh implication
  end;  
 
  { NAND }
  function nand(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a and b);
  end;
 
  { NOR }
  function nor(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a or b);
  end;
 
  { NXR }
  function nxr(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not (a xor b);
  end;
 
  { MNIMP material non-implication}
  function mnimp(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := a and not b;
  end;  
 
  { NIMP}
  function nimp(const a,b:Fuzz):Fuzz;inline;
  begin
    Result := not imp(a,b);
  end;  
 
begin
end.

There are also versions available as units where I just gave the code for some here.
Claude is good in writing examples, btw!! Just feed it your code.

Lazarus

Bookstore

Search

Recent

Author Topic: more logics and an erratum for Zadeh. (Read 694 times)

Thaddy

more logics and an erratum for Zadeh.

d2010

Re: more logics and an erratum for Zadeh.

Thaddy

Re: more logics and an erratum for Zadeh.

VisualLab

Re: more logics and an erratum for Zadeh.

	Computer Math and Games in Pascal (preview)
	Lazarus Handbook