#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i < (int)(b);++i)

using Long = long long;
template<typename W>
using Edge = pair<int, W>;
template<typename W>
using WeightedGraph = vector<vector<Edge<W>>>;
using UnWeightedGraph = vector< vector<int>>;

// Strongly Connected Component
// 時間計算量 : O(V+E)
template< typename G >
struct SCC {
    // G : Unweighted Graph or Weighted Graph
    // g : SCCを求める対象のグラフ
    const G &g;
    // forward : 順向きの辺
    // backward : 逆向きの辺
    UnWeightedGraph forward, backward;
    // comp[i] : 頂点iが属す強連結成分のindex
    // order : 1回目の順向きdfsの帰りがけ順を格納
    // used : 1回目の順向きdfsで通ったかを記憶
    vector< int > comp, order, used;

    SCC(UnWeightedGraph &g) : g(g), forward(g.size()), backward(g.size()), comp(g.size(), -1), used(g.size()) {
        for(int i = 0; i < g.size(); i++) {
            for(auto& e : g[i]) {
                forward[i].emplace_back((int) e);
                backward[(int) e].emplace_back(i);
            }
        }
    }

    template<typename W>
    SCC(WeightedGraph<W> &g) : g(g), forward(g.size()), backward(g.size()), comp(g.size(), -1), used(g.size()) {
        for(int i = 0; i < g.size(); i++) {
            for(auto& e : g[i]) {
                forward[i].emplace_back((int) e.first);
                backward[(int) e.first].emplace_back(i);
            }
        }
    }

    void dfs(int idx) {
        if(used[idx]) return;
        used[idx] = true;
        for(int to : forward[idx]) 
            dfs(to);
        // 帰りがけを記憶.
        order.push_back(idx);
    }

    void rdfs(int idx, int cnt) {
        if(comp[idx] != -1) return;
        comp[idx] = cnt;
        for(int to : backward[idx]) rdfs(to, cnt);
    }

    UnWeightedGraph buildDAG() {
        UnWeightedGraph DAG;
        for(int i = 0; i < forward.size(); i++) 
            dfs(i);
        // 帰りがけの遅かった頂点から探索
        reverse(begin(order), end(order));
        int ptr = 0;
        for(int i : order) {
            if(comp[i] == -1) {
                // 強連結ごとに逆向きdfsが停止.
                rdfs(i, ptr);
                ptr++;
            }
        }
        // DAG構築
        DAG.resize(ptr);
        for(int i = 0; i < g.size(); i++) {
            for(auto &&to : g[i]) {
                int x = comp[i], y = comp[to];
                if(x == y) continue;
                DAG[x].push_back(y);
            }
        }
        return DAG;
    }

    int build() {
        for(int i = 0; i < forward.size(); i++) 
            dfs(i);
        // 帰りがけの遅かった頂点から探索
        reverse(begin(order), end(order));
        int ptr = 0;
        for(int i : order) {
            if(comp[i] == -1) {
                // 強連結ごとに逆向きdfsが停止.
                rdfs(i, ptr);
                ptr++;
            }
        }
        return ptr;
    }
};

int main(void) {
    int N;
    while(true) {
        cin >> N;
        if ( N == 0) break;
        vector<double> p(N);
        UnWeightedGraph G(N);
        int m;
        rep(i, N) {
            cin >> p[i];
            cin >> m;
            rep(j, m) {
                int a;
                cin >> a;
                G[i].emplace_back(a-1);
            }
        }

        SCC<UnWeightedGraph> scc(G);
        int scc_num = scc.build();
        
        vector<int> is_root(scc_num, true);
        for(int i = 0; i < G.size(); i++) {
            for(auto &&to : G[i]) {
                int x = scc.comp[i], y = scc.comp[to];
                if(x == y) continue;
                is_root[y] = false;
            }
        }

        double ans = 1.0;
        for(int i = 0;i < scc_num;i++) {
            if (is_root[i]) {
                double gp = 1.0;
                rep(j, N) {
                    if (scc.comp[j] == i) 
                        gp *= p[j];
                }
                ans *= (1 - gp);
            }
        }
        cout << fixed << setprecision(10);
        cout << ans << endl;
    }
}


Measured memory_bytes: 3364