Saf işlevsel dillerde, ters işlevi elde etmek için bir algoritma var mı?

Haskell gibi saf işlevsel dillerde, bir işlevin tersini elde etmek için bir algoritma var mı? Ve işlevinizi öyle programlamanın belirli bir yolu var mı?

Bazı durumlarda evet! Ücretsiz Bidirectionalization adında güzel bir kağıt var ! Bu, birkaç durumu tartışır - fonksiyonunuz yeterince polimorfik olduğunda - ters fonksiyon türetmenin tamamen otomatik olarak mümkün olduğu durumlarda. (Ayrıca, işlevler polimorfik olmadığında sorunu neyin zorlaştırdığını da tartışır.)

Fonksiyonunuzun tersine çevrilebilir olması durumunda ortaya çıkardığınız şey tersidir (sahte bir girişle); diğer durumlarda, eski bir girdi değerini ve yeni bir çıktı değerini "birleştirmeye" çalışan bir işlev alırsınız.

Hayır, genel olarak mümkün değil.

İspat: tipin önyargılı işlevlerini düşünün

type F = [Bit] -> [Bit]

ile

data Bit = B0 | B1

inv :: F -> FBöyle bir invertörümüz olduğunu varsayalım inv f . f ≡ id. Diyelim ki işlev için test ettiğimizi f = idonaylayarak

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

B0Çıktıdaki bu ilk bir sonlu süreden sonra gelmiş olması gerektiğinden n, hem invbu sonucu elde etmek için test girdimizi gerçekten değerlendiren derinlikte hem de kaç kez çağrılabileceği konusunda bir üst sınırımız var f. Şimdi bir işlev ailesi tanımlayın

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

Açıkçası, herkes için 0<j≤n, g jaslında kendi kendine ters olan bir eşleştirme. Yani onaylayabilmeliyiz

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

ama bunu gerçekleştirmek inv (g j)için ya

• g j (B1 : repeat B0)derinliğine değerlendirmekn+j > n
• eşleşen head $ g j len az nfarklı listeler için değerlendirreplicate (n+j) B0 ++ B1 : ls

Bu noktaya kadar, bunlardan en az biri g jayırt edilemezdi fve inv fbu değerlendirmelerden hiçbirini yapmadığı inviçin, onu ayırması mümkün değildi - bazı çalışma zamanı ölçümlerini kendi başına yapmak dışında, ki bu sadece IO Monad.

                                                                                                                                   ⬜

Wikipedia'dan bakabilirsiniz, adı Tersine Çevrilebilir Hesaplama .

Genel olarak bunu yapamazsınız ve işlevsel dillerin hiçbirinde bu seçenek yoktur. Örneğin:

f :: a -> Int
f _ = 1

Bu işlevin tersi yoktur.

İşlevsel dillerin çoğunda değil, mantık programlamasında veya ilişkisel programlamada, tanımladığınız işlevlerin çoğu aslında işlevler değil "ilişkilerdir" ve bunlar her iki yönde de kullanılabilir. Örneğin prolog veya kanren'e bakın.

Bunun gibi görevler neredeyse her zaman kararlaştırılamaz. Bazı özel işlevler için bir çözümünüz olabilir, ancak genel olarak değil.

Burada hangi fonksiyonların tersi olduğunu bile anlayamazsınız. Barendregt'ten alıntı , HP Lambda Hesabı: Sözdizimi ve Anlambilim. Kuzey Hollanda, Amsterdam (1984) :

Ne boş ne de dolu küme ise, bir dizi lambda-terim önemsizdir. A ve B, (beta) eşitliği altında kapalı iki önemsiz, ayrık lambda terimleri kümesiyse, o zaman A ve B özyinelemeli olarak birbirinden ayrılamaz.

A'yı tersinir fonksiyonları temsil eden lambda terimleri kümesi olarak ve B'yi geri alalım. Her ikisi de boş değil ve beta eşitliği altında kapalı. Dolayısıyla bir fonksiyonun tersinir olup olmadığına karar vermek mümkün değildir.

(Bu türlenmemiş lambda hesabı için geçerlidir. TBH Tersine çevirmek istediğimiz bir işlevin türünü bildiğimizde, argümanın doğrudan yazılı bir lambda hesabına uyarlanıp uyarlanamayacağını bilmiyorum. Ama bunun olacağından oldukça eminim benzer.)

İşlevin etki alanını numaralandırabilir ve eşitlik aralığının öğelerini karşılaştırabilirseniz, bunu oldukça basit bir şekilde yapabilirsiniz. Numaralandırmakla, mevcut tüm öğelerin bir listesine sahip olmayı kastediyorum. Ocaml'ı bilmediğim için Haskell'e bağlı kalacağım (ya da nasıl büyük harfle yazılacağını bile ;-)

Yapmak istediğiniz şey, etki alanının öğelerini incelemek ve ters çevirmeye çalıştığınız aralığın öğesine eşit olup olmadıklarına bakmak ve işe yarayan ilkini almaktır:

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

Bunun fbir bijeksiyon olduğunu belirttiğinize göre , böyle bir unsur olması kaçınılmazdır. İşin püf noktası, elbette, etki alanı numaralandırmanızın aslında tüm öğelere sonlu bir zamanda ulaşmasını sağlamaktır . Eğer bir eşleşme ters çalışıyorsanız Integeriçin Integerkullanırken, [0,1 ..] ++ [-1,-2 ..]olmaz işi negatif sayılar olsun asla olarak. Somut olarak, inv ([0,1 ..] ++ [-1,-2 ..]) (+1) (-3)asla bir değer vermeyecektir.

Ancak, 0 : concatMap (\x -> [x,-x]) [1..]bu tamsayılar aşağıdaki sırayla çalıştığı için çalışacaktır [0,1,-1,2,-2,3,-3, and so on]. Indeed inv (0 : concatMap (\x -> [x,-x]) [1..]) (+1) (-3)hemen geri dönüyor -4!

Control.Monad.Omega paketi iyi bir şekilde küpe vs. listeleri yoluyla yönetmesini sağlayacak; Eminim bunun gibi daha fazla paket vardır - ama onları bilmiyorum.

Tabii ki, bu yaklaşım oldukça alçakgönüllü ve kaba kuvvetlidir, çirkin ve verimsizden bahsetmeye bile gerek yok! Öyleyse, sorunuzun son bölümünde, önyargıları nasıl 'yazacağınıza' dair birkaç yorumla bitireceğim. Haskell'in tip sistemi, bir fonksiyonun bir bijeksiyon olduğunu kanıtlamakla kalmaz - bunun için gerçekten Agda gibi bir şey istersiniz - ama size güvenmeye isteklidir.

(Uyarı: test edilmemiş kod izler)

Yani, Bijectiontürler arasında bir veri türü tanımlayabilir ave b:

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

İstediğiniz kadar sabitle birlikte (burada ' Önyükleme olduklarını biliyorum !' diyebilirsiniz !), örneğin:

notBi :: Bi Bool Bool
notBi = Bi not not

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

ve birkaç akıllı birleştirici, örneğin:

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)

Bence o zaman yapabilir invert (mapBi add1Bi) [1,5,6]ve alabilirsin [0,4,5]. Kombinatörlerinizi akıllıca seçerseniz Bi, elle sabit yazmak zorunda kalacağınız zamanın sayısı oldukça sınırlı olabilir.

Sonuçta, eğer bir fonksiyonun bijeksiyon olduğunu biliyorsanız, umarım bu gerçeğin kafanızda Curry-Howard izomorfizminin bir programa dönüştürebilmesi gereken bir kanıt taslağı olur :-)

Son zamanlarda bunun gibi konularla uğraşıyorum ve hayır, şunu söyleyebilirim (a) çoğu durumda zor değil, ama (b) hiç verimli değil.

Temel olarak, varsayalım ki sende var f :: a -> bve bu fgerçekten bir bjiection. Tersini f' :: b -> agerçekten aptalca bir şekilde hesaplayabilirsiniz :

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

Eğer fbir bijection ise ve enumerategerçekten tüm değerleri üretiyorsa a, sonunda aöyle bir şeye ulaşırsınız f a == b.

A Boundedve bir Enumörneğe sahip türler önemsiz bir şekilde yapılabilir RecursivelyEnumerable. Tür çiftleri Enumerablede yapılabilir 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

Aynısı Enumerabletürlerin ayrılması için de geçerlidir :

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

Aslında biz de bu yapabileceği (,)ve Eitherherhangi cebirsel veri türü için yapabilir muhtemelen anlamına gelir.

Her işlevin tersi yoktur. Tartışmayı bire bir işlevlerle sınırlarsanız, rastgele bir işlevi tersine çevirme yeteneği, herhangi bir şifreleme sistemini kırma yeteneği sağlar. Bunun teoride bile mümkün olmadığını ummalıyız!

Bazı durumlarda, bir önyargı işlevinin tersini sembolik bir temsile dönüştürerek bulmak mümkündür. Bu örneğe dayanarak, bazı basit polinom fonksiyonlarının tersini bulmak için bu Haskell programını yazdım:

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

Bu örnek yalnızca aritmetik ifadelerle çalışır, ancak muhtemelen listelerle de çalışmak üzere genelleştirilebilir.

Hayır, tüm işlevlerin tersi bile yoktur. Örneğin, bu işlevin tersi ne olur?

f x = 1