Trong các ngôn ngữ hàm thuần túy, có thuật toán nào để lấy hàm ngược không?

Trong các ngôn ngữ hàm thuần túy như Haskell, có thuật toán nào để lấy nghịch đảo của một hàm, (chỉnh sửa) khi nó là bijective không? Và có một cách cụ thể để lập trình chức năng của bạn như vậy không?

Trong một số trường hợp, có! Có một bài báo tuyệt đẹp được gọi là Hai chiều miễn phí! trong đó thảo luận về một số trường hợp - khi hàm của bạn đủ đa hình - khi có thể, hoàn toàn tự động để lấy ra một hàm ngược. (Nó cũng thảo luận về điều gì làm cho vấn đề trở nên khó khăn khi các hàm không đa hình.)

Những gì bạn nhận được trong trường hợp hàm của bạn là khả nghịch là nghịch đảo (với đầu vào giả); trong các trường hợp khác, bạn nhận được một hàm cố gắng "hợp nhất" một giá trị đầu vào cũ và một giá trị đầu ra mới.

Không, nói chung là không thể.

Chứng minh: hãy xem xét các hàm lưỡng tính của kiểu

type F = [Bit] -> [Bit]

với

data Bit = B0 | B1

Giả sử chúng ta có một biến tần inv :: F -> Fnhư vậy inv f . f ≡ id. Giả sử chúng tôi đã kiểm tra nó cho chức năng f = id, bằng cách xác nhận rằng

inv f (repeat B0) -> (B0 : ls)

Vì điều này đầu tiên B0trong đầu ra phải đến sau một khoảng thời gian hữu hạn, chúng tôi có giới hạn ntrên về cả độ sâu invđã thực sự đánh giá đầu vào thử nghiệm của chúng tôi để có được kết quả này, cũng như số lần nó có thể được gọi f. Xác định bây giờ một nhóm các hàm

g j (B1 : B0 : ... (n+j times) ... B0 : ls)
   = B0 : ... (n+j times) ... B0 : B1 : ls
g j (B0 : ... (n+j times) ... B0 : B1 : ls)
   = B1 : B0 : ... (n+j times) ... B0 : ls
g j l = l

Rõ ràng, đối với tất cả 0<j≤n, g jlà một sự phủ định, trên thực tế là tự ngược. Vì vậy, chúng tôi sẽ có thể xác nhận

inv (g j) (replicate (n+j) B0 ++ B1 : repeat B0) -> (B1 : ls)

nhưng để thực hiện điều này, inv (g j)cần phải

• đánh giá g j (B1 : repeat B0)đến độ sâu củan+j > n
• đánh giá head $ g j lcho ít nhất ncác danh sách khác nhau phù hợpreplicate (n+j) B0 ++ B1 : ls

Cho đến thời điểm đó, ít nhất một trong số g jkhông thể phân biệt được f, và vì inv fchưa thực hiện một trong hai đánh giá này, invnên không thể phân biệt được điều đó - thiếu việc thực hiện một số phép đo thời gian chạy, điều này chỉ có thể thực hiện được trong IO Monad.

                                                                                                                                   ⬜

Bạn có thể tra cứu nó trên wikipedia, nó có tên là Reversible Computing .

Nói chung, bạn không thể làm điều đó mặc dù và không có ngôn ngữ chức năng nào có tùy chọn đó. Ví dụ:

f :: a -> Int
f _ = 1

Hàm này không có nghịch đảo.

Không phải trong hầu hết các ngôn ngữ hàm, nhưng trong lập trình logic hoặc lập trình quan hệ, hầu hết các hàm bạn định nghĩa trên thực tế không phải là hàm mà là "quan hệ", và chúng có thể được sử dụng theo cả hai hướng. Xem ví dụ prolog hoặc kanren.

Những nhiệm vụ như thế này hầu như luôn không thể quyết định được. Bạn có thể có giải pháp cho một số chức năng cụ thể, nhưng không phải nói chung.

Ở đây, bạn thậm chí không thể nhận ra hàm nào có nghịch đảo. Trích dẫn Barendregt, HP Giải tích Lambda: Cú pháp và ngữ nghĩa của nó. Bắc Hà Lan, Amsterdam (1984) :

Một tập hợp các điều khoản lambda là không quan trọng nếu nó không phải là tập hợp rỗng hoặc không phải là tập hợp đầy đủ. Nếu A và B là hai tập hợp các số hạng lambda không đơn giản, rời rạc được đóng theo đẳng thức (beta), thì A và B không thể tách rời một cách đệ quy.

Hãy coi A là tập các số hạng lambda đại diện cho các hàm khả nghịch và B là phần còn lại. Cả hai đều không trống và đóng theo bình đẳng beta. Vì vậy, không thể quyết định liệu một hàm có khả nghịch hay không.

(Điều này áp dụng cho phép tính lambda không định kiểu. TBH Tôi không biết liệu đối số có thể được điều chỉnh trực tiếp với phép tính lambda đã nhập hay không khi chúng ta biết loại hàm mà chúng ta muốn đảo ngược. Nhưng tôi khá chắc chắn rằng nó sẽ như vậy giống.)

Nếu bạn có thể liệt kê miền của hàm và có thể so sánh các phần tử của phạm vi cho bằng nhau, bạn có thể - một cách khá đơn giản. Bằng cách liệt kê, tôi có nghĩa là có một danh sách tất cả các yếu tố có sẵn. Tôi sẽ gắn bó với Haskell, vì tôi không biết Ocaml (hoặc thậm chí làm thế nào để viết hoa nó đúng cách ;-)

Những gì bạn muốn làm là chạy qua các phần tử của miền và xem liệu chúng có bằng với phần tử của phạm vi mà bạn đang cố gắng đảo ngược hay không và lấy phần tử đầu tiên hoạt động:

inv :: Eq b => [a] -> (a -> b) -> (b -> a)
inv domain f b = head [ a | a <- domain, f a == b ]

Vì bạn đã nói rằng đó flà một phản ứng từ chối, nên nhất định phải có một và chỉ một phần tử như vậy. Tất nhiên, mẹo là đảm bảo rằng việc liệt kê miền của bạn thực sự đạt đến tất cả các phần tử trong một thời gian hữu hạn . Nếu bạn đang cố gắng đảo ngược một từ chối Integersang Integer, việc sử dụng [0,1 ..] ++ [-1,-2 ..]sẽ không hoạt động vì bạn sẽ không bao giờ chuyển đến các số âm. Nói một cách cụ thể, inv ([0,1 ..] ++ [-1,-2 ..]) (+1) (-3)sẽ không bao giờ mang lại giá trị.

Tuy nhiên, 0 : concatMap (\x -> [x,-x]) [1..]sẽ hoạt động, vì điều này chạy qua các số nguyên theo thứ tự sau [0,1,-1,2,-2,3,-3, and so on]. Quả thực inv (0 : concatMap (\x -> [x,-x]) [1..]) (+1) (-3)nhanh chóng trở lại -4!

Các Control.Monad.Omega gói có thể giúp bạn chạy qua danh sách các bộ etcetera trong một cách tốt; Tôi chắc rằng có nhiều gói như vậy nữa - nhưng tôi không biết chúng.

Tất nhiên, cách làm này khá thấp và thô bạo, chưa kể là xấu xí và không hiệu quả! Vì vậy, tôi sẽ kết thúc bằng một vài nhận xét về phần cuối cùng của câu hỏi của bạn, về cách 'viết' các tiểu sử. Loại hệ thống của Haskell không phải để chứng minh rằng một chức năng là một phản ứng - bạn thực sự muốn một cái gì đó giống như Agda cho điều đó - nhưng nó sẵn sàng tin tưởng bạn.

(Cảnh báo: sau mã chưa được kiểm tra)

Vì vậy, bạn có thể xác định một kiểu dữ liệu của Bijections giữa các kiểu avà b:

data Bi a b = Bi {
    apply :: a -> b,
    invert :: b -> a 
}

cùng với bao nhiêu hằng số (nơi bạn có thể nói 'Tôi biết chúng là những đường nhị phân!') như bạn muốn, chẳng hạn như:

notBi :: Bi Bool Bool
notBi = Bi not not

add1Bi :: Bi Integer Integer
add1Bi = Bi (+1) (subtract 1)

và một số tổ hợp thông minh, chẳng hạn như:

idBi :: Bi a a 
idBi = Bi id id

invertBi :: Bi a b -> Bi b a
invertBi (Bi a i) = (Bi i a)

composeBi :: Bi a b -> Bi b c -> Bi a c
composeBi (Bi a1 i1) (Bi a2 i2) = Bi (a2 . a1) (i1 . i2)

mapBi :: Bi a b -> Bi [a] [b]
mapBi (Bi a i) = Bi (map a) (map i)

bruteForceBi :: Eq b => [a] -> (a -> b) -> Bi a b
bruteForceBi domain f = Bi f (inv domain f)

Tôi nghĩ bạn có thể làm invert (mapBi add1Bi) [1,5,6]và nhận được [0,4,5]. Nếu bạn chọn các tổ hợp của mình một cách thông minh, tôi nghĩ rằng số lần bạn phải viết một Bihằng số bằng tay có thể khá hạn chế.

Rốt cuộc, nếu bạn biết một hàm là một phép phân tích, hy vọng bạn sẽ có một bản phác thảo bằng chứng về thực tế đó trong đầu, mà phép đẳng cấu Curry-Howard sẽ có thể biến thành một chương trình :-)

Gần đây tôi đã giải quyết các vấn đề như thế này và không, tôi muốn nói rằng (a) nó không khó trong nhiều trường hợp, nhưng (b) nó không hiệu quả chút nào.

Về cơ bản, giả sử bạn có f :: a -> b, và đó fthực sự là một bjiection. Bạn có thể tính toán nghịch đảo f' :: b -> amột cách thực sự ngu ngốc:

import Data.List

-- | Class for types whose values are recursively enumerable.
class Enumerable a where
    -- | Produce the list of all values of type @a@.
    enumerate :: [a]

 -- | Note, this is only guaranteed to terminate if @f@ is a bijection!
invert :: (Enumerable a, Eq b) => (a -> b) -> b -> Maybe a
invert f b = find (\a -> f a == b) enumerate

Nếu flà một bijection và enumeratethực sự tạo ra tất cả các giá trị của a, thì cuối cùng bạn sẽ đạt được một giá trị anhư vậy f a == b.

Các loại có một Boundedvà một Enumthể hiện có thể được thực hiện một cách nhẹ nhàng RecursivelyEnumerable. Các cặp Enumerableloại cũng có thể được thực hiện Enumerable:

instance (Enumerable a, Enumerable b) => Enumerable (a, b) where
    enumerate = crossWith (,) enumerate enumerate

crossWith :: (a -> b -> c) -> [a] -> [b] -> [c]
crossWith f _ [] = []
crossWith f [] _ = []
crossWith f (x0:xs) (y0:ys) =
    f x0 y0 : interleave (map (f x0) ys) 
                         (interleave (map (flip f y0) xs)
                                     (crossWith f xs ys))

interleave :: [a] -> [a] -> [a]
interleave xs [] = xs
interleave [] ys = []
interleave (x:xs) ys = x : interleave ys xs

Tương tự đối với các Enumerableloại kết hợp:

instance (Enumerable a, Enumerable b) => Enumerable (Either a b) where
    enumerate = enumerateEither enumerate enumerate

enumerateEither :: [a] -> [b] -> [Either a b]
enumerateEither [] ys = map Right ys
enumerateEither xs [] = map Left xs
enumerateEither (x:xs) (y:ys) = Left x : Right y : enumerateEither xs ys

Thực tế là chúng ta có thể làm điều này cho cả hai (,)và Eithercó lẽ có nghĩa là chúng ta có thể làm điều đó cho bất kỳ kiểu dữ liệu đại số nào.

Không phải mọi hàm đều có nghịch đảo. Nếu bạn giới hạn cuộc thảo luận ở các hàm một đối một, thì khả năng đảo ngược một hàm tùy ý sẽ cho phép bẻ khóa bất kỳ hệ thống mật mã nào. Chúng ta phải hy vọng điều này không khả thi, ngay cả trên lý thuyết!

Trong một số trường hợp, có thể tìm ra nghịch đảo của một hàm bijective bằng cách chuyển nó thành một biểu diễn tượng trưng. Dựa trên ví dụ này , tôi đã viết chương trình Haskell này để tìm nghịch đảo của một số hàm đa thức đơn giản:

bijective_function x = x*2+1

main = do
    print $ bijective_function 3
    print $ inverse_function bijective_function (bijective_function 3)

data Expr = X | Const Double |
            Plus Expr Expr | Subtract Expr Expr | Mult Expr Expr | Div Expr Expr |
            Negate Expr | Inverse Expr |
            Exp Expr | Log Expr | Sin Expr | Atanh Expr | Sinh Expr | Acosh Expr | Cosh Expr | Tan Expr | Cos Expr |Asinh Expr|Atan Expr|Acos Expr|Asin Expr|Abs Expr|Signum Expr|Integer
       deriving (Show, Eq)

instance Num Expr where
    (+) = Plus
    (-) = Subtract
    (*) = Mult
    abs = Abs
    signum = Signum
    negate = Negate
    fromInteger a = Const $ fromIntegral a

instance Fractional Expr where
    recip = Inverse
    fromRational a = Const $ realToFrac a
    (/) = Div

instance Floating Expr where
    pi = Const pi
    exp = Exp
    log = Log
    sin = Sin
    atanh = Atanh
    sinh = Sinh
    cosh = Cosh
    acosh = Acosh
    cos = Cos
    tan = Tan
    asin = Asin
    acos = Acos
    atan = Atan
    asinh = Asinh

fromFunction f = f X

toFunction :: Expr -> (Double -> Double)
toFunction X = \x -> x
toFunction (Negate a) = \a -> (negate a)
toFunction (Const a) = const a
toFunction (Plus a b) = \x -> (toFunction a x) + (toFunction b x)
toFunction (Subtract a b) = \x -> (toFunction a x) - (toFunction b x)
toFunction (Mult a b) = \x -> (toFunction a x) * (toFunction b x)
toFunction (Div a b) = \x -> (toFunction a x) / (toFunction b x)


with_function func x = toFunction $ func $ fromFunction x

simplify X = X
simplify (Div (Const a) (Const b)) = Const (a/b)
simplify (Mult (Const a) (Const b)) | a == 0 || b == 0 = 0 | otherwise = Const (a*b)
simplify (Negate (Negate a)) = simplify a
simplify (Subtract a b) = simplify ( Plus (simplify a) (Negate (simplify b)) )
simplify (Div a b) | a == b = Const 1.0 | otherwise = simplify (Div (simplify a) (simplify b))
simplify (Mult a b) = simplify (Mult (simplify a) (simplify b))
simplify (Const a) = Const a
simplify (Plus (Const a) (Const b)) = Const (a+b)
simplify (Plus a (Const b)) = simplify (Plus (Const b) (simplify a))
simplify (Plus (Mult (Const a) X) (Mult (Const b) X)) = (simplify (Mult (Const (a+b)) X))
simplify (Plus (Const a) b) = simplify (Plus (simplify b) (Const a))
simplify (Plus X a) = simplify (Plus (Mult 1 X) (simplify a))
simplify (Plus a X) = simplify (Plus (Mult 1 X) (simplify a))
simplify (Plus a b) = (simplify (Plus (simplify a) (simplify b)))
simplify a = a

inverse X = X
inverse (Const a) = simplify (Const a)
inverse (Mult (Const a) (Const b)) = Const (a * b)
inverse (Mult (Const a) X) = (Div X (Const a))
inverse (Plus X (Const a)) = (Subtract X (Const a))
inverse (Negate x) = Negate (inverse x)
inverse a = inverse (simplify a)

inverse_function x = with_function inverse x

Ví dụ này chỉ hoạt động với biểu thức số học, nhưng nó có thể được khái quát hóa để làm việc với danh sách.

Không, không phải tất cả các hàm đều có nghịch đảo. Ví dụ, nghịch đảo của hàm này sẽ là gì?

f x = 1