Select language: english | cesky | deutsch | italiano | simplified chinese | traditional chinese | hindi Concept: English word: Home

# list fn (ListFn)

A Function that takes any number of arguments and returns the List containing those arguments in exactly the same order.

## Ontology

SUMO / BASE-ONTOLOGY

## Class(es)

 varga

inheritable relation

prakaarya
 parivartaniiya sanbandha

list fn

## Coordinate term(s)

assignment fn  greatest common divisor fn  least common multiple fn  contrary attribute  disjoint decomposition  disjoint relation  exhaustive attribute  exhaustive decomposition  holds  partition

## Axioms (27)

```(=>
(equal ?OBJ1 ?OBJ2)
(=>
(and
(equal
?OBJ1
(ListOrderFn
(ListFn @ROW1)
?NUMBER))
(equal
?OBJ2
(ListOrderFn
(ListFn @ROW2)
?NUMBER))
(equal
(ListFn @ROW1)
(ListFn @ROW2)))
(<=>
(holds @ROW1)
(holds @ROW2))))```

• agar list1 is equal to list2,
• to agar list1 is equal to "()" aur list2 is equal to "()", to sab-kuch number ke lie hai, ki: "numberth element of "()"" is equal to "numberth element of "()""
• .
```(=>
(equal ?LIST1 ?LIST2)
(=>
(and
(equal
?LIST1
(ListFn @ROW1))
(equal
?LIST2
(ListFn @ROW2)))
(forall
(?NUMBER)
(equal
(ListOrderFn
(ListFn @ROW1)
?NUMBER)
(ListOrderFn
(ListFn @ROW2)
?NUMBER)))))```

Agar and ? are disjoint aur rel is a member of "()", to rel is an instance of sambandha.
```(=>
(and
(disjointRelation @ROW)
(inList
?REL
(ListFn @ROW)))
(instance ?REL Relation))```

Agar and ? are disjoint aur rel1 is a member of "()" aur rel2 is a member of "()" aur rel1 ke number konaanke bahanen hai, to rel2 ke number konaanke bahanen hai.
```(=>
(and
(disjointRelation @ROW)
(inList
?REL1
(ListFn @ROW))
(inList
?REL2
(ListFn @ROW))
(valence ?REL1 ?NUMBER))
(valence ?REL2 ?NUMBER))```

Agar and ? are disjoint aur rel1 is a member of "()" aur rel2 is a member of "()" aur rel1 is not equal to rel2 aur rel1() holds, to rel2() doesn't hold.
```(=>
(and
(disjointRelation @ROW1)
(inList
?REL1
(ListFn @ROW1))
(inList
?REL2
(ListFn @ROW1))
(not
(equal ?REL1 ?REL2))
(holds ?REL1 @ROW2))
(not
(holds ?REL2 @ROW2)))```

```(=>
(contraryAttribute @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Attribute)))```

• agar is opposed to ?,
• to sab-kuch attr1,attr2 ke lie hai, ki:
• .
```(=>
(contraryAttribute @ROW)
(forall
(?ATTR1 ?ATTR2)
(=>
(and
(equal
?ATTR1
(ListOrderFn
(ListFn @ROW)
?NUMBER1))
(equal
?ATTR2
(ListOrderFn
(ListFn @ROW)
?NUMBER2))
(not
(equal ?NUMBER1 ?NUMBER2)))
(=>
(property ?OBJ ?ATTR1)
(not
(property ?OBJ ?ATTR2))))))```

```(=>
(exhaustiveAttribute ?CLASS @ROW)
(=>
(inList
?ATTR
(ListFn @ROW))
(instance ?ATTR Attribute)))```

• agar exhaustive attribute(class,) ke lie hai, ki,
• to sab-kuch obj ke lie hai, ki: agar attr1 is an instance of class, to yah kuch attr2 nahin, ki attr2 is a member of "()" aur attr1 is equal to attr2
• .
```(=>
(exhaustiveAttribute ?CLASS @ROW)
(forall
(?OBJ)
(=>
(instance ?ATTR1 ?CLASS)
(exists
(?ATTR2)
(and
(inList
?ATTR2
(ListFn @ROW))
(equal ?ATTR1 ?ATTR2))))))```

```(=>
(exhaustiveDecomposition @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Class)))```

```(=>
(disjointDecomposition @ROW)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(instance ?ELEMENT Class)))```

rel is an instance of pUrNa mUlyaadeya sambandha agar hai yah kuch valence nahin, ki rel is an instance of sambandha aur rel ke valence konaanke bahanen hai aur
• agar sab-kuch number,element,class ke lie hai, ki: agar number is less than valence aur the number number argument of rel is an instance of class aur element is equal to "numberth element of "()"", to element is an instance of class,
• to yah kuch item nahin, ki rel(,item) holds
• .
```(<=>
(instance ?REL TotalValuedRelation)
(exists
(?VALENCE)
(and
(instance ?REL Relation)
(valence ?REL ?VALENCE)
(=>
(forall
(?NUMBER ?ELEMENT ?CLASS)
(=>
(and
(lessThan ?NUMBER ?VALENCE)
(domain ?REL ?NUMBER ?CLASS)
(equal
?ELEMENT
(ListOrderFn
(ListFn @ROW)
?NUMBER)))
(instance ?ELEMENT ?CLASS)))
(exists
(?ITEM)
(holds ?REL @ROW ?ITEM))))))```

Agar rel is an instance of intentional relation aur rel(agent,) holds aur obj is a member of "()", to agent is interested in obj.
```(=>
(and
(instance ?REL IntentionalRelation)
(holds ?REL ?AGENT @ROW)
(inList
?OBJ
(ListFn @ROW)))
(inScopeOfInterest ?AGENT ?OBJ))```

• agar class is covered by ,
• to sab-kuch obj ke lie hai, ki: agar obj is an instance of class, to yah kuch item nahin, ki item is a member of "()" aur obj is an instance of item
• .
```(=>
(exhaustiveDecomposition ?CLASS @ROW)
(forall
(?OBJ)
(=>
(instance ?OBJ ?CLASS)
(exists
(?ITEM)
(and
(inList
?ITEM
(ListFn @ROW))
(instance ?OBJ ?ITEM))))))```

• agar class is disjointly decomposed into ,
• to sab-kuch item ke lie hai, ki: agar item is a member of "()", to item is a subclass of class
• .
```(=>
(disjointDecomposition ?CLASS @ROW)
(forall
(?ITEM)
(=>
(inList
?ITEM
(ListFn @ROW))
(subclass ?ITEM ?CLASS))))```

• agar class is disjointly decomposed into ,
• to sab-kuch item1,item2 ke lie hai, ki: agar item1 is a member of "()" aur item2 is a member of "()" aur item1 is not equal to item2, to item1 asansavat item2 se hai
• .
```(=>
(disjointDecomposition ?CLASS @ROW)
(forall
(?ITEM1 ?ITEM2)
(=>
(and
(inList
?ITEM1
(ListFn @ROW))
(inList
?ITEM2
(ListFn @ROW))
(not
(equal ?ITEM1 ?ITEM2)))
(disjoint ?ITEM1 ?ITEM2))))```

Agar the number number argument of rel is an instance of class aur rel() holds, to "numberth element of "()"" is an instance of class.
```(=>
(and
(domain ?REL ?NUMBER ?CLASS)
(holds ?REL @ROW))
(instance
(ListOrderFn
(ListFn @ROW)
?NUMBER)
?CLASS))```

Agar the number number argument of rel is a subclass of class aur rel() holds, to "numberth element of "()"" is a subclass of class.
```(=>
(and
(domainSubclass ?REL ?NUMBER ?CLASS)
(holds ?REL @ROW))
(subclass
(ListOrderFn
(ListFn @ROW)
?NUMBER)
?CLASS))```

""(,item)" kii lambaaaii" is equal to "(""()" kii lambaaaii"+1)".
```(equal
(ListLengthFn
(ListFn @ROW ?ITEM))
(SuccessorFn
(ListLengthFn
(ListFn @ROW))))```

"""(,item)" kii lambaaaii"th element of "(,item)"" is equal to item.
```(equal
(ListOrderFn
(ListFn @ROW ?ITEM)
(ListLengthFn
(ListFn @ROW ?ITEM)))
?ITEM)```

• agar rel ke number konaanke bahanen hai,
• to sab-kuch ke lie hai, ki: agar rel() holds, to ""()" kii lambaaaii" is equal to number
• .
```(=>
(valence ?REL ?NUMBER)
(forall
(@ROW)
(=>
(holds ?REL @ROW)
(equal
(ListLengthFn
(ListFn @ROW))
?NUMBER))))```

"()" starts "(,item)".
```(initialList
(ListFn @ROW)
(ListFn @ROW ?ITEM))```

• agar "the greatest common divisor of " is equal to number,
• to sab-kuch element ke lie hai, ki: agar element is a member of "()", to "element mod number" is equal to
• .
```(=>
(equal
(GreatestCommonDivisorFn @ROW)
?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?ELEMENT ?NUMBER)
0))))```

• agar "the greatest common divisor of " is equal to number,
• to yah kuch greater nahin, ki greater is greater than number aur sab-kuch element ke lie hai, ki: agar element is a member of "()", to "element mod greater" is equal to
• .
```(=>
(equal
(GreatestCommonDivisorFn @ROW)
?NUMBER)
(not
(exists
(?GREATER)
(and
(greaterThan ?GREATER ?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?ELEMENT ?GREATER)
0)))))))```

• agar "the least common multiple of " is equal to number,
• to sab-kuch element ke lie hai, ki: agar element is a member of "()", to "number mod element" is equal to
• .
```(=>
(equal
(LeastCommonMultipleFn @ROW)
?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?NUMBER ?ELEMENT)
0))))```

• agar "the least common multiple of " is equal to number,
• to yah kuch less nahin, ki less is less than number aur sab-kuch element ke lie hai, ki: agar element is a member of "()", to "less mod element" is equal to
• .
```(=>
(equal
(LeastCommonMultipleFn @ROW)
?NUMBER)
(not
(exists
(?LESS)
(and
(lessThan ?LESS ?NUMBER)
(forall
(?ELEMENT)
(=>
(inList
?ELEMENT
(ListFn @ROW))
(equal
(RemainderFn ?LESS ?ELEMENT)
0)))))))```

Agar obj1 is attr1 to obj2 aur is opposed to ? aur attr1 is a member of "()" aur attr2 is a member of "()" aur attr1 is not equal to attr2, to obj1 is not attr2 to obj2.
```(=>
(and
(orientation ?OBJ1 ?OBJ2 ?ATTR1)
(contraryAttribute @ROW)
(inList
?ATTR1
(ListFn @ROW))
(inList
?ATTR2
(ListFn @ROW))
(not
(equal ?ATTR1 ?ATTR2)))
(not
(orientation ?OBJ1 ?OBJ2 ?ATTR2)))```