fact
string
imports
string
filename
string
symbolic_name
string
__index_level_0__
int64
Definition annot {A B} (a : A) (b : B) : A := a.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
0
Definition id {A} (x : A) := x.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
1
Definition var := nat.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
2
Definition iterate := fix iterate {A} (f : A -> A) n a := match n with | 0 => a | S n' => f(iterate f n' a) end.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
3
Definition funcomp {A B C : Type} (f : A -> B) (g : B -> C) x := g(f(x)).
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
4
Definition scons {X : Type} (s : X) (sigma : var -> X) (x : var) : X := match x with S y => sigma y | _ => s end.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
5
Definition lift (x y : var) : var := plus x y.
Coq.Program.Tactics Coq.Arith.PeanoNat List FunctionalExtensionality
coq-community-autosubst/Autosubst_Basics
coq-community-autosubst
6
Variable (A B C : Type).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
7
Variable (MMap_A_B : MMap A B).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
8
Variable (MMap_A_C : MMap A C).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
9
Variable (MMapLemmas_A_B : MMapLemmas A B).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
10
Variable (MMapLemmas_A_C : MMapLemmas A C).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
11
Variable (MMapExt_A_B : MMapExt A B).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
12
Variable (MMapExt_A_C : MMapExt A C).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_MMapInstances
coq-community-autosubst
13
Definition _bind (T1 : Type) (T2 : Type) (n : nat) := T2.
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
14
Definition scomp {A} `{Subst A} (f : var -> A) (g : var -> A) : var -> A := f >>> subst g.
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
15
Definition hcomp {A B} `{HSubst A B} (f : var -> B) (g : var -> A) : var -> B := f >>> hsubst g.
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
16
Definition ren {T} `{Ids T} (xi : var -> var) : var -> T := xi >>> ids.
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
17
Definition up {T} `{Ids T} `{Rename T} (sigma : var -> T) : var -> T := ids 0 .: sigma >>> rename (+1).
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
18
Definition upren (xi : var -> var) : (var -> var) := 0 .: xi >>> S.
Autosubst_Basics Autosubst_MMap
coq-community-autosubst/Autosubst_Classes
coq-community-autosubst
19
Axiom Pigeon_In_Hole : nat -> nat -> Prop.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
20
Definition cons_option {A: Type} (e: option A) (l: list A) := match e with | None => l | Some v => v:: l end.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
21
Fixpoint map_n (F: nat -> option Prop) (n: nat) := cons_option (F n) (match n with | O => nil | S n' => map_n F n' end).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
22
Fixpoint or_list (l: list Prop) := match l with | nil => False | e::nil => e | e::l => e \/ or_list l end.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
23
Fixpoint and_list (l: list Prop) := match l with | nil => True | e::nil => e | e::l => e /\ and_list l end.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
24
Definition big_or (n:nat) (F: nat -> option Prop) := or_list (map_n F n).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
25
Definition big_and (n:nat) (F: nat -> option Prop) := and_list (map_n F n).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
26
Fixpoint pigeon_in_hole (b:nat) (n:nat) : Prop := (big_or n (fun n => Some (Pigeon_In_Hole b n)) /\ match b with | O => True | S b' => pigeon_in_hole b' n end).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
27
Fixpoint forall_2 (P : nat -> nat -> option Prop) (i:nat) (j:nat) := big_and j (P i) /\ match i with | O => True | S i' => forall_2 P i' j end.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
28
Definition at_most_one_pigeon_per_hole (dis:bool) (b:nat) (k:nat) := let F i j := if dis then (not (Pigeon_In_Hole i k) \/ not (Pigeon_In_Hole j k)) else (Pigeon_In_Hole i k -> Pigeon_In_Hole j k -> False) in Some (forall_2 (fun i j => if Nat.ltb i j then Some (F i j) else None) b b).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
29
Definition at_most_one_pigeon (dis: bool) (b:nat) (n:nat) := big_and n (at_most_one_pigeon_per_hole dis b).
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
30
Definition pigeon_hole (dis: bool) (b:nat) (n:nat) := pigeon_in_hole b n /\ at_most_one_pigeon dis b n.
List
fbesson-itauto/benchmark/pigeon_hole
fbesson-itauto
31
Axiom width: Z.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_9
fbesson-itauto
32
Fixpoint compile(program: nat): list Z := match program with | S n => Z.of_nat n :: compile n | O => nil end.
ZArith List Cdcl.Itauto
fbesson-itauto/issues/issue_2
fbesson-itauto
33
Axiom F: list Z -> list Z.
ZArith List Cdcl.Itauto
fbesson-itauto/issues/issue_2
fbesson-itauto
34
Axiom X : Type.
ZArith List Cdcl.Itauto
fbesson-itauto/issues/issue_2
fbesson-itauto
35
Axiom x : X.
ZArith List Cdcl.Itauto
fbesson-itauto/issues/issue_2
fbesson-itauto
36
Axiom opaque_compile: nat -> list Z.
ZArith List Cdcl.Itauto
fbesson-itauto/issues/issue_2
fbesson-itauto
37
Variables A B : Set.
Cdcl.Itauto List ZArith Lia
fbesson-itauto/issues/issue_cc
fbesson-itauto
39
Variable P : A -> bool.
Cdcl.Itauto List ZArith Lia
fbesson-itauto/issues/issue_cc
fbesson-itauto
40
Variable R : A -> B -> Prop.
Cdcl.Itauto List ZArith Lia
fbesson-itauto/issues/issue_cc
fbesson-itauto
41
Definition Q (b : B) (r : A) := P r = true -> R r b.
Cdcl.Itauto List ZArith Lia
fbesson-itauto/issues/issue_cc
fbesson-itauto
42
Variable F : nat -> Prop.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_12
fbesson-itauto
43
Fixpoint orn (n : nat) := match n with | O => F 0 | S m => F n \/ orn m end.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_12
fbesson-itauto
44
Axiom Fbad : forall n, F n -> False.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_12
fbesson-itauto
45
Definition Register := Z.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_8
fbesson-itauto
46
Record ok (n: nat) := { getOk1: n <= 10 }.
Cdcl.Itauto Lia
fbesson-itauto/issues/issue_3
fbesson-itauto
47
Record ok' := { getP: Prop; getOk': getP }.
Cdcl.Itauto Lia
fbesson-itauto/issues/issue_3
fbesson-itauto
48
Definition block (A: Prop) := A.
Cdcl.Itauto
fbesson-itauto/issues/cnf
fbesson-itauto
49
Axiom word: Type.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_10
fbesson-itauto
51
Axiom w2z : word -> Z.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_10
fbesson-itauto
52
Axiom z2w : Z -> word.
Lia ZArith Cdcl.Itauto
fbesson-itauto/issues/issue_10
fbesson-itauto
53
Axiom stmt: Type.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
55
Axiom stackalloc_size: stmt -> Z.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
56
Axiom bytes_per_word: Z.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
57
Axiom list_union: forall {A: Type}, (A -> A -> bool) -> list A -> list A -> list A.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
58
Axiom modVars_as_list: (Z -> Z -> bool) -> stmt -> list Z.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
59
Axiom of_Z: Z -> word.
Cdcl.Itauto Uint63 Bool ZArith Lia Coq.Lists.List Coq.ZArith.ZArith Coq.micromega.Lia
fbesson-itauto/test-suite/arith
fbesson-itauto
60
Variable f : nat -> nat.
ZArith List Lia ZifyClasses Cdcl.NOlia
fbesson-itauto/test-suite/no_test_lia
fbesson-itauto
61
Axiom f : nat -> nat.
ZArith List Lia ZifyClasses Cdcl.NOlia
fbesson-itauto/test-suite/no_test_lia
fbesson-itauto
62
Variable f : R -> R.
ZArith List Lra ZifyClasses ZArith Cdcl.NOlra Reals
fbesson-itauto/test-suite/no_test_lra
fbesson-itauto
63
Axiom f : R -> R.
ZArith List Lra ZifyClasses ZArith Cdcl.NOlra Reals
fbesson-itauto/test-suite/no_test_lra
fbesson-itauto
64
Definition zero := 0%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
65
Definition one := 1%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
66
Definition int_of_nat (n:nat) := Uint63.of_Z (Z.of_nat n).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
67
Definition testbit (i:Uint63.int) (n:nat) := if 63 <=? n then false else Uint63.bit i (int_of_nat n).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
68
Definition interp:= (fun i => (Uint63.sub i one)).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
69
Definition is_mask := (fun (m: Uint63.int) (n: nat) => forall p, testbit m p = true <-> n = p).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
70
Variable P : nat -> bool.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
71
Fixpoint forall_n (n:nat) : bool := match n with | O => P O | S n' => P n && forall_n n' end.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
72
Variable P : nat -> nat -> bool.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
73
Fixpoint forall_2n (n:nat) (m:nat) := match n with | O => forall_n (P O) m | S n' => forall_n (P n) m && forall_2n n' m end.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
74
Definition mask_spec : forall m n, is_mask m n -> if 63 <=? n then False else m = Uint63.lsl one (int_of_nat n).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
75
Definition ones (n:int) := ((1 << n) - 1)%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
76
Definition split_m (i: int) (m: int) := ( (i land ((ones digits) << m)) lor ((i land (ones m))))%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
77
Definition is_set (k:int) (m:nat) := (forall p, (p < m)%nat -> testbit k p = false) /\ testbit k m = true.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
78
Definition is_set_int (k:int) (m:int) := (forall p, (p <? m = true)%uint63 -> bit k p = false) /\ bit k m = true.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
79
Definition nat_of_int (i:int) := Z.to_nat (to_Z i).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
80
Definition not_int (x : int) := (- x - 1)%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
81
Definition bit_excl (x y: int) := (forall n : int, bit x n = true -> bit y n = true -> False).
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
82
Definition lowest_bit (x: int) := (x land (opp x))%uint63.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
83
Fixpoint find_lowest (n: nat) (k: int) (p: nat) := match p with | O => n | S q => if testbit k (n - p)%nat then (n - p)%nat else find_lowest n k q end.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
84
Definition digits := Some 63%nat.
Bool ZifyClasses ZifyUint63 ZArith Lia Cdcl.PatriciaR
fbesson-itauto/theories/KeyInt
fbesson-itauto
85
Record RarithThy : Type.
Cdcl.Itauto ZifyClasses Lra Reals
fbesson-itauto/theories/NOlra
fbesson-itauto
86
Axiom t: Type.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
87
Axiom zero: t.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
88
Axiom eqb: t -> t -> bool.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
89
Axiom testbit: t -> nat -> bool.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
90
Axiom interp: t -> t.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
91
Axiom land: t -> t -> t.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
92
Axiom lxor: t -> t -> t.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
93
Axiom lopp: t -> t.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
94
Axiom ltb: t -> t -> bool.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
95
Definition is_mask (m: t) (n: nat) := forall p, testbit m p = true <-> n = p.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
96
Axiom zero_spec: forall n, testbit zero n = false.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
97
Axiom eqb_spec : forall k1 k2, eqb k1 k2 = true <-> k1 = k2.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
98
Axiom testbit_spec: forall k1 k2, (forall n, testbit k1 n = testbit k2 n) -> k1 = k2.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
99
Axiom interp_spec: forall m n, is_mask m n -> forall p, testbit (interp m) p = true <-> (p < n)%nat.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
100
Axiom land_spec: forall n k1 k2, testbit (land k1 k2) n = testbit k1 n && testbit k2 n.
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
101
Axiom lxor_spec: forall n k1 k2, testbit (lxor k1 k2) n = xorb (testbit k1 n) (testbit k2 n).
Lia Cdcl.Coqlib
fbesson-itauto/theories/Patricia
fbesson-itauto
102

Dataset Name: Coq Facts, Propositions and Proofs

Dataset Description

The CoqFactsPropsProofs dataset aims to enhance Large Language Models' (LLMs) proficiency in interpreting and generating Coq code by providing a comprehensive collection of over 10,000 Coq source files. It encompasses a wide array of propositions, proofs, and definitions, enriched with metadata including source references and licensing information. This dataset is designed to facilitate the development of models capable of generating syntactically correct and semantically meaningful Coq constructs, thereby advancing automated theorem proving.

A detailed description can be found in the paper Enhancing Formal Theorem Proving: A Comprehensive Dataset for Training AI Models on Coq Code.

Composition

  • Files: Over 10,000 Coq source files (.v files).
  • Tables: Three distinct tables: facts (definitions or notations), propositions (theorems and lemmas alongside proofs), and licensing/repository information.
  • Entries: 103,446 facts and 166,035 propositions with proofs.
  • Size: Character length ranging from as short as 11 to as long as 177,585 characters.
  • Source and Collection Method: The Coq source files were collected from various internet sources, focusing on repositories pivotal within the Coq community. These sources range from foundational libraries and formalized mathematical theorems to computer science theories and algorithm implementations. The collection process prioritized quality, relevance, and the contribution of each source to the Coq ecosystem.

Licenses

The dataset includes a diverse range of open-source licenses, reflecting the variety in the Coq community and the broader open-source ecosystem. Some of the licenses included are MIT, GPL (versions 2.0 and 3.0), LGPL (versions 2.1 and 3.0), Apache 2.0, BSD (2-Clause and 3-Clause), CECILL (versions 1.0, 2.1, B, C), MPL-2.0, and the UniMath License. Each entry in the dataset links to detailed license information, ensuring compliance and redistribution legality.

Usage

This dataset is provided in three parquet files and can be employed in a variety of ways depending on the use case. An example usage case includes training or fine-tuning models to focus on proofs rather than definitions and notations. The dataset also allows for filtering based on specific licenses using the info.parquet file.

import pandas as pd

df_facts_raw = pd.read_parquet("facts.parquet")
df_info = pd.read_parquet("info.parquet")

# This is the list of licenses which might be seen as permissive
permissive_licenses_list = [
    'Apache-2.0', 'BSD-2-Clause', 'BSD-3-Clause',
    'CECILL-B', 'CECILL-C', 
    'LGPL-2.1-only', 'LGPL-2.1-or-later', 'LGPL-3.0-only', 'LGPL-3.0-or-later', 
    'MIT', 'MPL-2.0', 'UniMath' ]

# Set the license-type to permissive based on the list
df_info['license-type'] = df_info['spdx-id'].apply(
    lambda x: 'permissive' if x in permissive_licenses_list else 'not permissive')

# Merge df_facts with df_info to get the license-type information
# 'symbolic_name' is the common key in both DataFrames
df_facts_merged = pd.merge(df_facts_raw, df_info, on='symbolic_name', how='left')

# Filter the merged DataFrame to only include entries with a permissive license
df_facts = df_facts_merged[df_facts_merged['license-type'] == 'permissive']

Experiments and Findings

Initial experiments with the dataset have demonstrated its potential in improving the accuracy of LLMs in generating Coq code. Fine-tuning an existing base model with this dataset resulted in outputs predominantly in Coq syntax, highlighting the dataset's efficacy in specialized model training for formal theorem proving.

Challenges and Limitations

  • High standard deviations in fact, proposition, and proof lengths indicate the presence of outliers with significantly long content.
  • The complexity of licensing and the manual process of license identification for each repository.

Cite

@misc{florath2024enhancing,
      title={Enhancing Formal Theorem Proving: A Comprehensive Dataset for Training AI Models on Coq Code}, 
      author={Andreas Florath},
      year={2024},
      eprint={2403.12627},
      archivePrefix={arXiv},
      primaryClass={cs.AI}
}

Legal Disclaimer

This dataset is provided 'as is' and without any warranty or guarantee of accuracy, completeness, or compliance with any specific legal regime. While every effort has been made to ensure that license information is accurate and up-to-date, users of this dataset are responsible for verifying the licensing information of each snippet and complying with all applicable licenses and copyright laws. Users should consider seeking legal advice to ensure their use of these snippets complies with the original authors' licensing terms and any other applicable regulations. The creators of this dataset shall not be held liable for any infringements or legal challenges arising from the use of or reliance on any materials contained within this dataset.

Downloads last month
18
Edit dataset card