• Home
• tools.aqua
• cvc5-turnkey
• 1.2.0
• source code
• rewrites-regexp-membership

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

cvc5-cvc5-1.2.0.src.theory.strings.rewrites-regexp-membership Maven / Gradle / Ivy

; =============== Regular expression membership rules

(define-rule re-in-empty ((t String)) (str.in_re t re.none) false)
(define-rule re-in-sigma ((t String)) (str.in_re t re.allchar) (= (str.len t) 1))
(define-rule re-in-sigma-star ((t String)) (str.in_re t (re.* re.allchar)) true)
(define-rule re-in-cstring ((t String) (s String)) (str.in_re t (str.to_re s)) (= t s))
(define-rule re-in-comp ((t String) (r RegLan)) (str.in_re t (re.comp r)) (not (str.in_re t r)))

(define-rule* str-in-re-union-elim ((s String) (r1 RegLan) (r2 RegLan) (rs RegLan :list))
  (str.in_re s (re.union r1 r2 rs))
  (str.in_re s (re.union r2 rs))
  (or (str.in_re s r1) _))

(define-rule* str-in-re-inter-elim ((s String) (r1 RegLan) (r2 RegLan) (rs RegLan :list))
  (str.in_re s (re.inter r1 r2 rs))
  (str.in_re s (re.inter r2 rs))
  (and (str.in_re s r1) _))

(define-cond-rule str-in-re-range-elim ((s String) (c1 String) (c2 String))
  (and (= (str.len c1) 1) (= (str.len c2) 1))
  (str.in_re s (re.range c1 c2))
  (and (<= (str.to_code c1) (str.to_code s)) (<= (str.to_code s) (str.to_code c2))))

(define-rule str-in-re-contains ((t String) (s String))
  (str.in_re t (re.++ (re.* re.allchar) (str.to_re s) (re.* re.allchar)))
  (str.contains t s))

(define-rule* str-in-re-strip-prefix ((s String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list) (r RegLan :list))
  (str.in_re (str.++ s s1 s2) (re.++ (str.to_re (str.++ s sr1 sr2)) r))  
  (str.in_re (str.++ s1 s2) (re.++ (str.to_re (str.++ sr1 sr2)) r))
  _)

(define-cond-rule str-in-re-strip-prefix-neg ((s String) (t String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list) (r RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s s1 s2) (re.++ (str.to_re (str.++ t sr1 sr2)) r))  
  false)

(define-rule* str-in-re-strip-prefix-sr-single ((s String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (str.in_re (str.++ s s1 s2) (re.++ (str.to_re s) r1 r2))  
  (str.in_re (str.++ s1 s2) (re.++ r1 r2))
  _)

(define-cond-rule str-in-re-strip-prefix-sr-single-neg ((s String) (t String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s s1 s2) (re.++ (str.to_re t) r1 r2))  
  false)

(define-rule str-in-re-strip-prefix-srs-single ((s String) (r1 RegLan) (r2 RegLan :list))
  (str.in_re s (re.++ (str.to_re s) r1 r2))  
  (str.in_re "" (re.++ r1 r2)))

(define-cond-rule str-in-re-strip-prefix-srs-single-neg ((s String) (t String) (r1 RegLan) (r2 RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (re.++ (str.to_re t) r1 r2))  
  false)

(define-rule str-in-re-strip-prefix-s-single ((s String) (sr1 String) (sr2 String :list) (r RegLan :list))
  (str.in_re s (re.++ (str.to_re (str.++ s sr1 sr2)) r))  
  (str.in_re "" (re.++ (str.to_re (str.++ sr1 sr2)) r)))

(define-cond-rule str-in-re-strip-prefix-s-single-neg ((s String) (t String) (sr1 String) (sr2 String :list) (r RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (re.++ (str.to_re (str.++ t sr1 sr2)) r))  
  false)

(define-rule* str-in-re-strip-prefix-base ((s String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list))
  (str.in_re (str.++ s s1 s2) (str.to_re (str.++ s sr1 sr2)))
  (str.in_re (str.++ s1 s2) (str.to_re (str.++ sr1 sr2)))
  _)

(define-cond-rule str-in-re-strip-prefix-base-neg ((s String) (t String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s s1 s2) (str.to_re (str.++ t sr1 sr2)))
  false)

(define-rule str-in-re-strip-prefix-base-s-single ((s String) (sr1 String) (sr2 String :list))
  (str.in_re s (str.to_re (str.++ s sr1 sr2)))
  (str.in_re "" (str.to_re (str.++ sr1 sr2))))

(define-cond-rule str-in-re-strip-prefix-base-s-single-neg ((s String) (t String) (sr1 String) (sr2 String :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (str.to_re (str.++ t sr1 sr2)))
  false)

(define-cond-rule str-in-re-strip-char ((s String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (= (str.len s) 1)
  (str.in_re (str.++ s s1 s2) (re.++ re.allchar r1 r2))
  (str.in_re (str.++ s1 s2) (re.++ r1 r2)))

(define-cond-rule str-in-re-strip-char-s-single ((s String) (r1 RegLan) (r2 RegLan :list))
  (= (str.len s) 1)
  (str.in_re s (re.++ re.allchar r1 r2))
  (str.in_re "" (re.++ r1 r2)))

(define-rule* str-in-re-strip-prefix-rev ((s String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list) (r RegLan :list))
  (str.in_re (str.++ s1 s2 s) (re.++ r (str.to_re (str.++ sr1 sr2 s))))
  (str.in_re (str.++ s1 s2) (re.++ r (str.to_re (str.++ sr1 sr2))))
  _)

(define-cond-rule str-in-re-strip-prefix-neg-rev ((s String) (t String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list) (r RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s1 s2 s) (re.++ r (str.to_re (str.++ sr1 sr2 t))))
  false)

(define-rule* str-in-re-strip-prefix-sr-single-rev ((s String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (str.in_re (str.++ s1 s2 s) (re.++ r1 r2 (str.to_re s)))
  (str.in_re (str.++ s1 s2) (re.++ r1 r2))
  _)

(define-cond-rule str-in-re-strip-prefix-sr-single-neg-rev ((s String) (t String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s1 s2 s) (re.++ r1 r2 (str.to_re t)))
  false)

(define-rule str-in-re-strip-prefix-srs-single-rev ((s String) (r1 RegLan) (r2 RegLan :list))
  (str.in_re s (re.++ r1 r2 (str.to_re s)))  
  (str.in_re "" (re.++ r1 r2)))

(define-cond-rule str-in-re-strip-prefix-srs-single-neg-rev ((s String) (t String) (r1 RegLan) (r2 RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (re.++ r1 r2 (str.to_re t)))  
  false)

(define-rule str-in-re-strip-prefix-s-single-rev ((s String) (sr1 String) (sr2 String :list) (r RegLan :list))
  (str.in_re s (re.++ r (str.to_re (str.++ sr1 sr2 s))))  
  (str.in_re "" (re.++ r (str.to_re (str.++ sr1 sr2)))))

(define-cond-rule str-in-re-strip-prefix-s-single-neg-rev ((s String) (t String) (sr1 String) (sr2 String :list) (r RegLan :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (re.++ r (str.to_re (str.++ sr1 sr2 t))))
  false)

(define-rule* str-in-re-strip-prefix-base-rev ((s String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list))
  (str.in_re (str.++ s1 s2 s) (str.to_re (str.++ sr1 sr2 s)))
  (str.in_re (str.++ s1 s2) (str.to_re (str.++ sr1 sr2)))
  _)

(define-cond-rule str-in-re-strip-prefix-base-neg-rev ((s String) (t String) (s1 String) (s2 String :list) (sr1 String) (sr2 String :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re (str.++ s1 s2 s) (str.to_re (str.++ sr1 sr2 t)))
  false)

(define-rule str-in-re-strip-prefix-base-s-single-rev ((s String) (sr1 String) (sr2 String :list))
  (str.in_re s (str.to_re (str.++ sr1 sr2 s)))
  (str.in_re "" (str.to_re (str.++ sr1 sr2))))

(define-cond-rule str-in-re-strip-prefix-base-s-single-neg-rev ((s String) (t String) (sr1 String) (sr2 String :list))
  (and (= (str.len s) (str.len t)) (not (= s t)))
  (str.in_re s (str.to_re (str.++ sr1 sr2 t)))
  false)

(define-cond-rule str-in-re-strip-char-rev ((s String) (s1 String) (s2 String :list) (r1 RegLan) (r2 RegLan :list))
  (= (str.len s) 1)
  (str.in_re (str.++ s1 s2 s) (re.++ r1 r2 re.allchar))
  (str.in_re (str.++ s1 s2) (re.++ r1 r2)))

(define-cond-rule str-in-re-strip-char-s-single-rev ((s String) (r1 RegLan) (r2 RegLan :list))
  (= (str.len s) 1)
  (str.in_re s (re.++ r1 r2 re.allchar))
  (str.in_re "" (re.++ r1 r2)))

(define-cond-rule str-in-re-req-unfold ((s String) (r1 RegLan) (r2 RegLan) (r3 RegLan :list))
  (not (str.in_re s (re.++ r2 r3)))
  (str.in_re s (re.++ (re.* r1) r2 r3))
  (str.in_re s (re.++ r1 (re.* r1) r2 r3)))

(define-cond-rule str-in-re-req-unfold-rev ((s String) (r1 RegLan) (r2 RegLan :list) (r3 RegLan))
  (not (str.in_re s (re.++ r1 r2)))
  (str.in_re s (re.++ r1 r2 (re.* r3)))
  (str.in_re s (re.++ r1 r2 (re.* r3) r3)))

(define-cond-rule str-in-re-skip-unfold ((s String) (r1 RegLan) (r2 RegLan) (r3 RegLan :list))
  (not (str.in_re s (re.++ r1 (re.* r1) r2 r3)))
  (str.in_re s (re.++ (re.* r1) r2 r3))
  (str.in_re s (re.++ r2 r3)))

(define-cond-rule str-in-re-skip-unfold-rev ((s String) (r1 RegLan) (r2 RegLan :list) (r3 RegLan))
  (not (str.in_re s (re.++ r1 r2 (re.* r3) r3)))
  (str.in_re s (re.++ r1 r2 (re.* r3)))
  (str.in_re s (re.++ r1 r2)))

(define-cond-rule str-in-re-test-unfold ((s String) (r1 RegLan) (r2 RegLan) (r3 RegLan :list))
  (and (not (str.in_re s (re.++ r2 r3))) (not (str.in_re s (re.++ r1 (re.* r1) r2 r3))))
  (str.in_re s (re.++ (re.* r1) r2 r3))
  false)

(define-cond-rule str-in-re-test-unfold-rev ((s String) (r1 RegLan) (r2 RegLan :list) (r3 RegLan))
  (and (not (str.in_re s (re.++ r1 r2))) (not (str.in_re s (re.++ r1 r2 (re.* r3) r3))))
  (str.in_re s (re.++ r1 r2 (re.* r3)))
  false)