import java.util.HashSet;
import java.util.function.Predicate;

/*
java.util.function.Predicate is an interface, essentially same as:
interface Predicate<T>
{
   boolean test(T x);
}
*/

    
// Sets and Infinite Sets

interface Set<D>
{
    boolean contains(D x);
    void add(D x);  // destructive addition
    Set<D> union(Set<D> setB);
    Set<D> intersection(Set<D> setB);
    Set<D> complement();
    boolean subset(Set<D> setB);
    Set<D> clone();
}


class Fset<D> implements Set<D>  // finite sets using a java.util.HashSet
{
    HashSet<D> HS;
    public Fset() // constructor creates empty set
    {
	HS = new HashSet<D>();
    }
    public Fset(D[] A) // constructor creates set from array
    {
	HS = new HashSet<D>();
	for(D x:A) HS.add(x);
    }
    public boolean contains(D x) { return HS.contains(x); }
    public void add(D x) { HS.add(x); }
    public Set<D> clone()
    {
	Fset<D> Cloneset = new Fset<D>();
	for(D x:HS) Cloneset.add(x); // for loop on HashSet
	return Cloneset;
    }
    
    public Set<D> union(Set<D> B)
    {
	Set<D> BC = B.clone();  // don't know what kind of set B is
	for(D x: HS) BC.add(x);
	return BC;
    }
    public Set<D> intersection(Set<D> B)
    {
	Set<D> Intsect = new Fset<D>();
	for(D x:HS) if (B.contains(x)) Intsect.add(x);
	return Intsect;
    }
    
    public Set<D> complement()
    {
	return new Pset<D>( (x)->!HS.contains(x) );
    }
    public boolean subset(Set<D> B)
    {
	for(D x:HS) if (!B.contains(x)) return false;
	return true;
    }
}//Fset


class Pset<D> implements Set<D> // predicate sets of domain type D
{
    protected Predicate<D> p = (x)->false;  // default predicate is empty set
    public Pset(Predicate<D> q)
    {
	if (q!=null) p=q;
    }
    public boolean contains(D x) { return p.test(x); }

    public void add(D x)
    {
	Predicate<D> p0 = p; // copy original
	p = (y) -> y.equals(x) || p0.test(x); // change predicate
    }
    public Set<D> clone()
    {
	Predicate<D> pc=p;
	return new Pset<D>(pc); 
    }
    public Set<D> union(Set<D> B)
    {
	return new Pset<D>((x)-> this.contains(x) || B.contains(x));
    }
    public Set<D> intersection(Set<D> B)
    {
	if (B instanceof Fset) return B.intersection(this); //??? why
	// indicates limitations of dynamic dispatch paradigm.
	return new Pset<D>((x)-> this.contains(x) && B.contains(x));
    }
    public Set<D> complement()
    {
	return new Pset<D>((x)->!this.contains(x));
    }
    public boolean subset(Set<D> B)
    {
	throw new RuntimeException("no general algorithm for Pset.subset");
    }
}//Pset

public class sets2
{
    // testing if a number is prime
    public static boolean isprime(int n)
    {
	if (n==2) return true; // only even prime
	if (n<2 || n%2==0) return false; // rules out evens, <2 nums
	boolean answer = true;
	int limit = (int)(Math.sqrt(n)+1);
	for(int i=3;i<limit && answer;i+=2)
	    if (n%i==0) answer=false;
	return answer;
    }
    public static boolean sumof2primes(int n)
    {
	for(int i=2;i<n;i++)
	    if (isprime(i) && isprime(n-i)) return true;
	return false;
    }
    
    public static void main(String[] av)
    {
	// set of all odd numbers
	Set<Integer> Odds = new Pset<Integer>( (n)->n%2==1 );
	// set of all positive numbers:
	Set<Integer> Positives = new Pset<Integer>( (x)->x>0 );
	// set of all positive even numbers
	Set<Integer> Evens = Odds.complement().intersection(Positives);
	System.out.println(Evens.contains(8)); //true
	System.out.println(Evens.contains(9));	//false
	// finite set
	Integer[] P = {3,5,7,11,13};
	var F = new Fset<Integer>(P);
	F.add(2);

	// set of all primes:
	Set<Integer> Primes = new Pset<Integer>((x)->isprime(x));
	System.out.println(Primes.contains(15)); //false
	System.out.println(Primes.contains(19)); //true
	// set of all finite subsets of primes

	Set<Fset<Integer>> FSP = new Pset<Fset<Integer>>((s)->s.subset(Primes));
	System.out.println(FSP.contains(F)); // true

	// is every even number greater than 2 the sum of two primes?

	Set<Integer> EG2 = new Pset<Integer>((x)->x>2 && x%2==0);
	Set<Integer> Sum2ps = new Pset<Integer>( (x)-> sumof2primes(x) );

	System.out.println(EG2.subset(Sum2ps)); //??? Goldbach's Conjecture
    }//main
}

// even .contains may not be definable, because .contains may never
// return at all - Halting problem.