IRI:http://www.w3.org/ns/prov#ActivityInvolvement
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_ActivityInvolvement.ttl"%}{% endescape %}
IRI:http://www.w3.org/ns/prov#AgentInvolvement
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_AgentInvolvement.ttl"%}{% endescape %}
IRI:http://www.w3.org/ns/prov#Association
An activity association is an assignment of responsibility to an agent for an activity, indicating that the agent had a role in the activity. It further allows for a plan to be specified, which is the plan intended by the agent to achieve some goals in the context of this activity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Association.ttl"%}{% endescape %}
An instance of prov:Association provides additional descriptions about the binary prov:wasAssociatedWith relation from an prov:Activity to some prov:Agent that is responsible for it. For example, :baking prov:wasAssociatedWith :baker; prov:qualified [ a prov:Association; prov:agent :baker; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Attribution
Attribution is the ascribing of an entity to an agent.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Attribution.ttl"%}{% endescape %}
An instance of prov:Attribution provides additional descriptions about the binary prov:wasAttributedTo relation from an prov:Entity to some prov:Agent that is responsible for it. For example, :cake prov:wasAttributedTo :baker; prov:qualified [ a prov:Attribution; prov:entity :baker; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Communication
Communication is the exchange of an entity by two activities, one activity using the entity generated by the other.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Communication.ttl"%}{% endescape %}
An instance of prov:Communication provides additional descriptions about the binary prov:wasInformedBy relation from an informed prov:Activity to the prov:Activity that informed it. For example, :you_jumping_off_bridge prov:wasInformedBy :everyone_else_jumping_off_bridge; prov:qualifiedCommunication [ a prov:Communication; prov:entity :everyone_else_jumping_off_bridge; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Delegation
Delegation is the assignment of authority and responsibility to an agent (by itself or by another agent) to carry out a specific activity as a delegate or representative, while the agent it acts on behalf of retains some responsibility for the outcome of the delegated work.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Delegation.ttl"%}{% endescape %}
An instance of prov:Delegation provides additional descriptions about the binary prov:actedOnBehalfOf relation from a performing prov:Agent to some prov:Agent for whom it was performed. For example, :mixing prov:wasAssociatedWith :toddler . :toddler prov:actedOnBehalfOf :mother; prov:qualifiedDelegation [ a prov:Delegation; prov:entity :mother; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Derivation
A derivation is a transformation of an entity into another, a construction of an entity into another, or an update of an entity, resulting in a new one.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Derivation.ttl"%}{% endescape %}
An instance of prov:Derivation provides additional descriptions about the binary prov:wasDerivedFrom relation from some prov:Entity to another prov:Entity. For example, :chewed_bubble_gum prov:wasDerivedFrom :unwrapped_bubble_gum; prov:qualified [ a prov:Derivation; prov:entity :unwrapped_bubble_gum; :foo :bar ].
IRI:http://www.w3.org/ns/prov#End
An activity end event is the instantaneous event that marks the instant an activity ends.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_End.ttl"%}{% endescape %}
An instance of prov:End provides additional descriptions about the binary prov:wasEndedBy relation from some ended prov:Activity to an prov:Entity that ended it. For example, :ball_game prov:wasEndedBy :buzzer; prov:qualified [ a prov:Usage; prov:entity :buzzer; :foo :bar; prov:atTime '2012-03-09T08:05:08-05:00'^^xsd:dateTime ].
IRI:http://www.w3.org/ns/prov#EntityInvolvement
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_EntityInvolvement.ttl"%}{% endescape %}
IRI:http://www.w3.org/ns/prov#Generation
An entity generation event is the instantaneous event that marks the final instant of an entity's creation timespan, after which it is no longer available for use.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Generation.ttl"%}{% endescape %}
An instance of prov:Generation provides additional descriptions about the binary prov:wasGeneratedBy relation from a generated prov:Entity to the prov:Activity that generated it. For example, :cake prov:wasGeneratedBy :baking; prov:qualifiedGeneration [ a prov:Generation; prov:activity :baking; :foo :bar ].
IRI:http://www.w3.org/ns/prov#InstantaneousEvent
An instantaneous event, or event for short, happens in the world and marks a change in the world, in its activities and in its entities. The term 'event' is commonly used in process algebra with a similar meaning. Events represent communications or interactions; they are assumed to be atomic and instantaneous.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_InstantaneousEvent.ttl"%}{% endescape %}
An instantaneous event, or event for short, happens in the world and marks a change in the world, in its activities and in its entities. The term 'event' is commonly used in process algebra with a similar meaning. Events represent communications or interactions; they are assumed to be atomic and instantaneous.
IRI:http://www.w3.org/ns/prov#Invalidation
Invalidation is the start of the destruction, cessation, or expiry of an existing entity by an activity. The entity is no longer available for use after invalidation. Any generation or usage of an entity precedes its invalidation.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Invalidation.ttl"%}{% endescape %}
IRI:http://www.w3.org/ns/prov#Involvement
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Involvement.ttl"%}{% endescape %}
Any resource that involved an prov:Activity, prov:Entity, or prov:Agent can qualify its involvement by also referencing an instance of prov:Involvement. Instances of prov:Involvement reference the involved Activity, Entity, or Agent (using prov:activity, prov:entity, or prov:agent, respectively) and may be described with any kind of attributes, including user-defined attributes and those provided by PROV (prov:hadRole, prov:hadPlan, prov:atTime, prov:hadLocation). A description (via prov:Involvement) of the binary involvement implies the assertion of the binary involvement.
IRI:http://www.w3.org/ns/prov#Plan
A plan is an entity that represents a set of actions or steps intended by one or more agents to achieve some goals.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Plan.ttl"%}{% endescape %}
There exist no prescriptive requirement on the nature of plans, their representation, the actions or steps they consist of, or their intended goals. Since plans may evolve over time, it may become necessary to track their provenance, so plans themselves are entities. Representing the plan explicitly in the provenance can be useful for various tasks: for example, to validate the execution as represented in the provenance record, to manage expectation failures, or to provide explanations.
IRI:http://www.w3.org/ns/prov#Quotation
A quotation is the repeat of (some or all of) an entity, such as text or image, by someone other than its original author.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Quotation.ttl"%}{% endescape %}
An instance of prov:Quotation provides additional descriptions about the binary prov:wasQuotedFrom relation from some prov:Entity to another prov:Entity. For example, :here_is_looking_at_you_kid prov:wasQuotedFrom :casablanca_script; prov:qualified [ a prov:Quotation; prov:entity :casablanca_script; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Revision
A revision is a derivation that revises an entity into a revised version.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Revision.ttl"%}{% endescape %}
An instance of prov:Revision provides additional descriptions about the binary prov:wasRevisionOf relation from some prov:Entity to another prov:Entity. For example, :draft_2 prov:wasRevisionOf :draft_1; prov:qualified [ a prov:Source; prov:entity :draft_1; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Role
A Role is the function of an entity with respect to an activity, in the context of a usage, generation, association, start, and end.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Role.ttl"%}{% endescape %}
A Role is the function of an entity with respect to an activity, in the context of a usage, generation, association, start, and end.
IRI:http://www.w3.org/ns/prov#Source
An original source refers to the source material that is closest to the person, information, period, or idea being studied.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Source.ttl"%}{% endescape %}
An instance of prov:Source provides additional descriptions about the binary prov:hadOriginalSource relation from some prov:Entity to another prov:Entity. For example, :blog prov:hadOriginalSource :newsArticle; prov:qualified [ a prov:Source; prov:entity :newsArticle; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Start
An activity start event is the instantaneous event that marks the instant an activity starts.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Start.ttl"%}{% endescape %}
An instance of prov:Start provides additional descriptions about the binary prov:wasStartedBy relation from some started prov:Activity to an prov:Entity that started it. For example, :foot_race prov:wasStartedBy :bang; prov:qualified [ a prov:Usage; prov:entity :bang; :foo :bar; prov:atTime '2012-03-09T08:05:08-05:00'^^xsd:dateTime ].
IRI:http://www.w3.org/ns/prov#Trace
Traceability is the ability to link back an entity to another by means of derivation or responsibility relations, possibly repeatedly traversed.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Trace.ttl"%}{% endescape %}
An instance of prov:Trace provides additional descriptions about the binary prov:tracedTo relation from some prov:Entity to some other prov:Element. For example, :stomach_ache prov:tracedTo :spoon; prov:qualified [ a prov:Trace; prov:entity :spoon; :foo :bar ].
IRI:http://www.w3.org/ns/prov#Usage
A usage is an instantaneous world event: an activity beginning to consume an entity. Before this event, the activity had not begun to consume or use to this entity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/class_Usage.ttl"%}{% endescape %}
An instance of prov:Usage provides additional descriptions about the binary prov:used relation from some prov:Activity to an prov:Entity that it used. For example, :keynote prov:used :podium; prov:qualified [ a prov:Usage; prov:entity :podium; :foo :bar ].
IRI:http://www.w3.org/ns/prov#activity
prov:ActivityInvolvement provides descriptions of any binary involvement between any instance and an prov:Activity. The property prov:activity is used to reference the object of the triple being described.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_activity.ttl"%}{% endescape %}
has characteristics Functional
IRI:http://www.w3.org/ns/prov#agent
prov:AgentInvolvement provides descriptions of any binary involvement between any instance and an prov:Agent. The property prov:agent is used to reference the object of the triple being described.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_agent.ttl"%}{% endescape %}
The property used by a prov:AgentInvolvement to cite the Agent that was prov:involved with either an Activity or Entity. It can be used to express the agent involved in being responsible for an activity, being attributed to an entity, starting or ending an activity, or being responsible for another subordinate agent in an activity.
has characteristics Functional
IRI:http://www.w3.org/ns/prov#atTime
An instantaneous event, or event for short, happens in the world and marks a change in the world, in its activities and in its entities. The term 'event' is commonly used in process algebra with a similar meaning. Events represent communications or interactions; they are assumed to be atomic and instantaneous.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_atTime.ttl"%}{% endescape %}
The time at which an InstantaneousEvent occurred, in the form of xsd:dateTime. This property is predominantly used on Involvements such as Generation, Usage, and Invalidation.
has characteristics Functional
IRI:http://www.w3.org/ns/prov#entity
prov:EntityInvolvement provides descriptions of any binary involvement between any instance and an prov:Entity. The property prov:entity is used to reference the object of the triple being described.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_entity.ttl"%}{% endescape %}
The property used by an prov:EntityInvolvement to cite the Entity that was prov:involved with either an Activity or Entity. It can be used to refer to the entity involved in deriving another entity, being quoted or revised from, being the source of another entity, or being used in an activity.
has characteristics Functional
IRI:http://www.w3.org/ns/prov#hadActivity
An activity is something that occurs over a period of time and acts upon or with entities; it may include consuming, processing, transforming, modifying, relocating, using, or generating entities.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_hadActivity.ttl"%}{% endescape %}
The _optional_ Activity of an Involvement, which used, generated, invalidated, or was the responsibility of some Entity. This property is _not_ used by ActivityInvolvement (use prov:activity instead).
has characteristics Functional
IRI:http://www.w3.org/ns/prov#hadGeneration
An entity generation event is the instantaneous event that marks the final instant of an entity's creation timespan, after which it is no longer available for use.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_hadGeneration.ttl"%}{% endescape %}
The _optional_ Generation involved in an Entity's Derivation.
has characteristics Functional
IRI:http://www.w3.org/ns/prov#hadPlan
A plan is an entity that represents a set of actions or steps intended by one or more agents to achieve some goals.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_hadPlan.ttl"%}{% endescape %}
The _optional_ Plan adopted by an Agent in Association with some Activity. Plan specifications are out of the scope of this specification.
has characteristics Irreflexive, Functional, Asymmetric
IRI:http://www.w3.org/ns/prov#hadRole
A usage is an instantaneous world event: an activity beginning to consume an entity. Before this event, the activity had not begun to consume or use to this entity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_hadRole.ttl"%}{% endescape %}
The _optional_ Role that an Entity assumes in the context of an Activity. For example, :baking prov:used :spoon; prov:qualified [ a prov:Usage; prov:entity :spoon; prov:hadRole roles:mixing_implement ].
has characteristics Irreflexive
IRI:http://www.w3.org/ns/prov#hadUsage
A usage is an instantaneous world event: an activity beginning to consume an entity. Before this event, the activity had not begun to consume or use to this entity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_hadUsage.ttl"%}{% endescape %}
The _optional_ Usage involved in an Entity's Derivation.
has characteristics Functional
IRI:http://www.w3.org/ns/prov#involved
The broadest provenance relation between two resources, prov:involved is the superproperty of all unqualified binary relations among any two Activities, Entities, or Agents (or anything else). A more specific property should be favored of prov:involved.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_involved.ttl"%}{% endescape %}
IRI:http://www.w3.org/ns/prov#involvee
The rdf:object of the (binary) prov:involved relation (triple) that this Involvement is qualifying (reifying) for further description (as an n-ary relation).
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_involvee.ttl"%}{% endescape %}
Subproperties of prov:involvee are used to cite the object of an unqualified PROV-O triple whose predicate is a subproperty of prov:involved (e.g. prov:used, prov:wasGeneratedBy). prov:involvee is used much like rdf:object is used.
IRI:http://www.w3.org/ns/prov#qualifiedAssociation
An activity association is an assignment of responsibility to an agent for an activity, indicating that the agent had a role in the activity. It further allows for a plan to be specified, which is the plan intended by the agent to achieve some goals in the context of this activity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedAssociation.ttl"%}{% endescape %}
If this Activity prov:wasAssociatedWith Agent :ag, then it can qualify the Association using prov:qualifiedAssociation [ a prov:Association; prov:agent :ag; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedAttribution
Attribution is the ascribing of an entity to an agent.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedAttribution.ttl"%}{% endescape %}
If this Entity prov:wasAttributedTo Agent :ag, then it can qualify how it was using prov:qualifiedAttribution [ a prov:Attribution; prov:agent :ag; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedCommunication
Communication is the exchange of an entity by two activities, one activity using the entity generated by the other.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedCommunication.ttl"%}{% endescape %}
If this Activity prov:wasInformedBy Activity :a, then it can qualify how it was Inform[ed] using prov:qualifiedCommunication [ a prov:Communication; prov:activity :a; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedDelegation
Delegation is the assignment of authority and responsibility to an agent (by itself or by another agent) to carry out a specific activity as a delegate or representative, while the agent it acts on behalf of retains some responsibility for the outcome of the delegated work.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedDelegation.ttl"%}{% endescape %}
If this Agent prov:actedOnBehalfOf Agent :ag, then it can qualify how with prov:qualifiedResponsibility [ a prov:Responsibility; prov:agent :ag; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedDerivation
A derivation is a transformation of an entity into another, a construction of an entity into another, or an update of an entity, resulting in a new one.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedDerivation.ttl"%}{% endescape %}
If this Entity prov:wasDerivedFrom Entity :e, then it can qualify how it was derived using prov:qualifiedDerivation [ a prov:Derivation; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedEnd
An activity end event is the instantaneous event that marks the instant an activity ends.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedEnd.ttl"%}{% endescape %}
If this Activity prov:wasEndedBy Entity :e1, then it can qualify how it was ended using prov:qualifiedEnd [ a prov:End; prov:entity :e1; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedGeneration
An entity generation event is the instantaneous event that marks the final instant of an entity's creation timespan, after which it is no longer available for use.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedGeneration.ttl"%}{% endescape %}
If this Activity prov:generated Entity :e, then it can qualify how it did performed the Generation using prov:qualifiedGeneration [ a prov:Generation; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedInvalidation
Invalidation is the start of the destruction, cessation, or expiry of an existing entity by an activity. The entity is no longer available for use after invalidation. Any generation or usage of an entity precedes its invalidation.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedInvalidation.ttl"%}{% endescape %}
If this Entity prov:wasInvalidatedBy Activity :a, then it can qualify how it was invalidated using prov:qualifiedInvalidation [ a prov:Invalidation; prov:activity :a; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedQuotation
A quotation is the repeat of (some or all of) an entity, such as text or image, by someone other than its original author.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedQuotation.ttl"%}{% endescape %}
If this Entity prov:wasQuotedFrom Entity :e, then it can qualify how using prov:qualifiedQuotation [ a prov:Quotation; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedRevision
A revision is a derivation that revises an entity into a revised version.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedRevision.ttl"%}{% endescape %}
If this Entity prov:wasRevisionOf Entity :e, then it can qualify how it was revised using prov:qualifiedRevision [ a prov:Revision; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedSource
An original source refers to the source material that is closest to the person, information, period, or idea being studied.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedSource.ttl"%}{% endescape %}
If this Entity prov:hadOriginalSource Entity :e, then it can qualify how using prov:qualifiedSource [ a prov:Source; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedStart
An activity start event is the instantaneous event that marks the instant an activity starts.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedStart.ttl"%}{% endescape %}
If this Activity prov:wasStartedBy Entity :e1, then it can qualify how it was started using prov:qualifiedStart [ a prov:Start; prov:entity :e1; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedTrace
Traceability is the ability to link back an entity to another by means of derivation or responsibility relations, possibly repeatedly traversed.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedTrace.ttl"%}{% endescape %}
If this prov:wasAttributedTo Entity :e, then it can qualify how using prov:qualifiedTrace [ a prov:Trace; prov:entity :e; :foo :bar ]. If this prov:wasAttributedTo Activity :a, then it can qualify how using prov:qualifiedTrace [ a prov:Trace; prov:activity :a; :foo :bar ].
has characteristics Inverse Functional
IRI:http://www.w3.org/ns/prov#qualifiedUsage
A usage is an instantaneous world event: an activity beginning to consume an entity. Before this event, the activity had not begun to consume or use to this entity.
{% escape %}{% include "includes/prov/examples/eg-24-prov-o-html-examples/rdf/create/rdf/property_qualifiedUsage.ttl"%}{% endescape %}
If this Activity prov:used Entity :e, then it can qualify how it used it using prov:qualifiedUsage [ a prov:Usage; prov:entity :e; :foo :bar ].
has characteristics Inverse Functional
The property used by an prov:ActivityInvolvement to cite the prov:Activity that was involved with either an Activity or Entity. It can be used to refer to the activity involved in generating an entity, informing another activity, or starting another activity.


Shetland Pony
Everything Shetland Pony
Home
About Us
Photos
Videos
Poems
Jokes
Games
Home of everything Shetland Pony!
Velkomin
Hope you enjoy
Written by kevin.
Contact us at kbplaygrounds@gmail.com


{% extends '_base.html' %} {% block title %}100 theorems in Lean{% endblock %} {% block content %}
Freek Wiedijk maintains a list tracking progress of theorem provers in formalizing 100 classic theorems in mathematics as a way of comparing prominent theorem provers. Currently {{hundred_theorems|selectattr('author')|list|length}} of them are formalized in Lean. We also have a page with the theorems from the list not yet in mathlib.
{% for theorem in hundred_theorems|selectattr('author') %}Author{% if ',' in theorem.author %}s{% endif %}: {{ theorem.author }}
{% if theorem.statement %}{{ theorem.statement }}
{% markdown %}{{ theorem.note }}{% endmarkdown %}
{% endif %} {% endfor %} {% endblock %}


Keyword: parameter
A parameter is a value supplied by the environment before initialization.
A parameter is declared like this:
parameter p : t
where p
is the parameter name and t
is the type.
Parameters may be declared anywhere in the object hierarchy.
Except for the fact that it is initialized by the environment, a parameter is identical to an individual.
The manner in which parameters are supplied is dependent on the compiler. For example, if a program is compiled to an executable file, the parameter values are supplied on the command line. If it is compiled to a class in C++, parameters are supplied as arguments to the constructor.
In either case, the order of parameters is the same as their order of declaration in the program.


UPC-A consists of 12 numeric digits represented by strips of black bars and white spaces.
Every UPC-A code can be easily converted to the equivalent EAN-13 code by prepending "0" to the UPC-A code.
UPC-E is a zero-suppressed version of UPC to allow the use of UPC barcodes on smaller packages. It can only correspond to certain UPC-A numbers starting with 0 or 1.


| 1 | /*- |
| 2 | * Copyright (c) 2011-2012 Irene Ruengeler |
| 3 | * Copyright (c) 2011-2012 Michael Tuexen |
| 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions |
| 8 | * are met: |
| 9 | * 1. Redistributions of source code must retain the above copyright |
| 10 | * notice, this list of conditions and the following disclaimer. |
| 11 | * 2. Redistributions in binary form must reproduce the above copyright |
| 12 | * notice, this list of conditions and the following disclaimer in the |
| 13 | * documentation and/or other materials provided with the distribution. |
| 14 | * |
| 15 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
| 16 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 17 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 18 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| 19 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 20 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 21 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 22 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 23 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 24 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 25 | * SUCH DAMAGE. |
| 26 | * |
| 27 | */ |
| 28 | |
| 29 | |
| 30 | #ifdef _WIN32 |
| 31 | #include <netinet/sctp_pcb.h> |
| 32 | #include <sys/timeb.h> |
| 33 | #include <iphlpapi.h> |
| 34 | #if !defined(__MINGW32__) |
| 35 | #pragma comment(lib, "iphlpapi.lib") |
| 36 | #endif |
| 37 | #endif |
| 38 | #include <netinet/sctp_os_userspace.h> |
| 39 | #if defined(__FreeBSD__) |
| 40 | #include <pthread_np.h> |
| 41 | #endif |
| 42 | |
| 43 | #if defined(__linux__) |
| 44 | #include <sys/prctl.h> |
| 45 | #endif |
| 46 | |
| 47 | #if defined(_WIN32) |
| 48 | /* Adapter to translate Unix thread start routines to Windows thread start |
| 49 | * routines. |
| 50 | */ |
| 51 | #if defined(__MINGW32__) |
| 52 | #pragma GCC diagnostic push |
| 53 | #pragma GCC diagnostic ignored "-Wpedantic" |
| 54 | #endif |
| 55 | static DWORD WINAPI |
| 56 | sctp_create_thread_adapter(void *arg) { |
| 57 | start_routine_t start_routine = (start_routine_t)arg; |
| 58 | return start_routine(NULL) == NULL; |
| 59 | } |
| 60 | |
| 61 | int |
| 62 | sctp_userspace_thread_create(userland_thread_t *thread, start_routine_t start_routine) |
| 63 | { |
| 64 | *thread = CreateThread(NULL, 0, sctp_create_thread_adapter, |
| 65 | (void *)start_routine, 0, NULL); |
| 66 | if (*thread == NULL) |
| 67 | return GetLastError(); |
| 68 | return 0; |
| 69 | } |
| 70 | |
| 71 | #if defined(__MINGW32__) |
| 72 | #pragma GCC diagnostic pop |
| 73 | #endif |
| 74 | |
| 75 | #else |
| 76 | int |
| 77 | sctp_userspace_thread_create(userland_thread_t *thread, start_routine_t start_routine) |
| 78 | { |
| 79 | return pthread_create(thread, NULL, start_routine, NULL); |
| 80 | } |
| 81 | #endif |
| 82 | |
| 83 | void |
| 84 | sctp_userspace_set_threadname(const char *name) |
| 85 | { |
| 86 | #if defined(__APPLE__) |
| 87 | pthread_setname_np(name); |
| 88 | #endif |
| 89 | #if defined(__linux__) |
| 90 | prctl(PR_SET_NAME, name); |
| 91 | #endif |
| 92 | #if defined(__FreeBSD__) |
| 93 | pthread_set_name_np(pthread_self(), name); |
| 94 | #endif |
| 95 | } |
| 96 | |
| 97 | #if !defined(_WIN32) && !defined(__native_client__) |
| 98 | int |
| 99 | sctp_userspace_get_mtu_from_ifn(uint32_t if_index, int af) |
| 100 | { |
| 101 | #if defined(INET) || defined(INET6) |
| 102 | struct ifreq ifr; |
| 103 | int fd; |
| 104 | #endif |
| 105 | int mtu; |
| 106 | |
| 107 | switch (af) { |
| 108 | #if defined(INET) |
| 109 | case AF_INET: |
| 110 | #endif |
| 111 | #if defined(INET6) |
| 112 | case AF_INET6: |
| 113 | #endif |
| 114 | #if defined(INET) || defined(INET6) |
| 115 | memset(&ifr, 0, sizeof(struct ifreq)); |
| 116 | mtu = 0; |
| 117 | if (if_indextoname(if_index, ifr.ifr_name) != NULL) { |
| 118 | /* TODO can I use the raw socket here and not have to open a new one with each query? */ |
| 119 | if ((fd = socket(af, SOCK_DGRAM, 0)) < 0) { |
| 120 | break; |
| 121 | } |
| 122 | if (ioctl(fd, SIOCGIFMTU, &ifr) >= 0) { |
| 123 | mtu = ifr.ifr_mtu; |
| 124 | } |
| 125 | close(fd); |
| 126 | } |
| 127 | break; |
| 128 | #endif |
| 129 | case AF_CONN: |
| 130 | mtu = 1280; |
| 131 | break; |
| 132 | default: |
| 133 | mtu = 0; |
| 134 | break; |
| 135 | } |
| 136 | return (mtu); |
| 137 | } |
| 138 | #endif |
| 139 | |
| 140 | #if defined(__native_client__) |
| 141 | int |
| 142 | sctp_userspace_get_mtu_from_ifn(uint32_t if_index, int af) |
| 143 | { |
| 144 | return 1280; |
| 145 | } |
| 146 | #endif |
| 147 | |
| 148 | #if defined(__APPLE__) || defined(__DragonFly__) || defined(__linux__) || defined(__native_client__) || defined(__NetBSD__) || defined(_WIN32) || defined(__Fuchsia__) || defined(__EMSCRIPTEN__) |
| 149 | int |
| 150 | timingsafe_bcmp(const void *b1, const void *b2, size_t n) |
| 151 | { |
| 152 | const unsigned char *p1 = b1, *p2 = b2; |
| 153 | int ret = 0; |
| 154 | |
| 155 | for (; n > 0; n--) |
| 156 | ret |= *p1++ ^ *p2++; |
| 157 | return (ret != 0); |
| 158 | } |
| 159 | #endif |
| 160 | |
| 161 | #ifdef _WIN32 |
| 162 | int |
| 163 | sctp_userspace_get_mtu_from_ifn(uint32_t if_index, int af) |
| 164 | { |
| 165 | #if defined(INET) || defined(INET6) |
| 166 | PIP_ADAPTER_ADDRESSES pAdapterAddrs, pAdapt; |
| 167 | DWORD AdapterAddrsSize, Err; |
| 168 | #endif |
| 169 | int mtu; |
| 170 | |
| 171 | switch (af) { |
| 172 | #if defined(INET) |
| 173 | case AF_INET: |
| 174 | #endif |
| 175 | #if defined(INET6) |
| 176 | case AF_INET6: |
| 177 | #endif |
| 178 | #if defined(INET) || defined(INET6) |
| 179 | mtu = 0; |
| 180 | AdapterAddrsSize = 0; |
| 181 | pAdapterAddrs = NULL; |
| 182 | if ((Err = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &AdapterAddrsSize)) != 0) { |
| 183 | if ((Err != ERROR_BUFFER_OVERFLOW) && (Err != ERROR_INSUFFICIENT_BUFFER)) { |
| 184 | SCTPDBG(SCTP_DEBUG_USR, "GetAdaptersAddresses() sizing failed with error code %d, AdapterAddrsSize = %d\n" , Err, AdapterAddrsSize); |
| 185 | mtu = -1; |
| 186 | goto cleanup; |
| 187 | } |
| 188 | } |
| 189 | if ((pAdapterAddrs = (PIP_ADAPTER_ADDRESSES) GlobalAlloc(GPTR, AdapterAddrsSize)) == NULL) { |
| 190 | SCTPDBG(SCTP_DEBUG_USR, "Memory allocation error!\n" ); |
| 191 | mtu = -1; |
| 192 | goto cleanup; |
| 193 | } |
| 194 | if ((Err = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, pAdapterAddrs, &AdapterAddrsSize)) != ERROR_SUCCESS) { |
| 195 | SCTPDBG(SCTP_DEBUG_USR, "GetAdaptersAddresses() failed with error code %d\n" , Err); |
| 196 | mtu = -1; |
| 197 | goto cleanup; |
| 198 | } |
| 199 | for (pAdapt = pAdapterAddrs; pAdapt; pAdapt = pAdapt->Next) { |
| 200 | if (pAdapt->IfIndex == if_index) { |
| 201 | mtu = pAdapt->Mtu; |
| 202 | break; |
| 203 | } |
| 204 | } |
| 205 | cleanup: |
| 206 | if (pAdapterAddrs != NULL) { |
| 207 | GlobalFree(pAdapterAddrs); |
| 208 | } |
| 209 | break; |
| 210 | #endif |
| 211 | case AF_CONN: |
| 212 | mtu = 1280; |
| 213 | break; |
| 214 | default: |
| 215 | mtu = 0; |
| 216 | break; |
| 217 | } |
| 218 | return (mtu); |
| 219 | } |
| 220 | |
| 221 | void |
| 222 | getwintimeofday(struct timeval *tv) |
| 223 | { |
| 224 | FILETIME filetime; |
| 225 | ULARGE_INTEGER ularge; |
| 226 | |
| 227 | GetSystemTimeAsFileTime(&filetime); |
| 228 | ularge.LowPart = filetime.dwLowDateTime; |
| 229 | ularge.HighPart = filetime.dwHighDateTime; |
| 230 | /* Change base from Jan 1 1601 00:00:00 to Jan 1 1970 00:00:00 */ |
| 231 | #if defined(__MINGW32__) |
| 232 | ularge.QuadPart -=<PHONE_NUMBER>00000000ULL; |
| 233 | #else |
| 234 | ularge.QuadPart -=<PHONE_NUMBER>00000000UI64; |
| 235 | #endif |
| 236 | /* |
| 237 | * ularge.QuadPart is now the number of 100-nanosecond intervals |
| 238 | * since Jan 1 1970 00:00:00. |
| 239 | */ |
| 240 | #if defined(__MINGW32__) |
| 241 | tv->tv_sec = (long)(ularge.QuadPart / 10000000ULL); |
| 242 | tv->tv_usec = (long)((ularge.QuadPart % 10000000ULL) / 10ULL); |
| 243 | #else |
| 244 | tv->tv_sec = (long)(ularge.QuadPart / 10000000UI64); |
| 245 | tv->tv_usec = (long)((ularge.QuadPart % 10000000UI64) / 10UI64); |
| 246 | #endif |
| 247 | } |
| 248 | |
| 249 | int |
| 250 | win_if_nametoindex(const char *ifname) |
| 251 | { |
| 252 | IP_ADAPTER_ADDRESSES *addresses, *addr; |
| 253 | ULONG status, size; |
| 254 | int index = 0; |
| 255 | |
| 256 | if (!ifname) { |
| 257 | return 0; |
| 258 | } |
| 259 | |
| 260 | size = 0; |
| 261 | status = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size); |
| 262 | if (status != ERROR_BUFFER_OVERFLOW) { |
| 263 | return 0; |
| 264 | } |
| 265 | addresses = malloc(size); |
| 266 | status = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, addresses, &size); |
| 267 | if (status == ERROR_SUCCESS) { |
| 268 | for (addr = addresses; addr; addr = addr->Next) { |
| 269 | if (addr->AdapterName && !strcmp(ifname, addr->AdapterName)) { |
| 270 | index = addr->IfIndex; |
| 271 | break; |
| 272 | } |
| 273 | } |
| 274 | } |
| 275 | |
| 276 | free(addresses); |
| 277 | return index; |
| 278 | } |
| 279 | |
| 280 | #if WINVER < 0x0600 |
| 281 | /* These functions are written based on the code at |
| 282 | * http://www.cs.wustl.edu/~schmidt/win32-cv-1.html |
| 283 | * Therefore, for the rest of the file the following applies: |
| 284 | * |
| 285 | * |
| 286 | * Copyright and Licensing Information for ACE(TM), TAO(TM), CIAO(TM), |
| 287 | * DAnCE(TM), and CoSMIC(TM) |
| 288 | * |
| 289 | * [1]ACE(TM), [2]TAO(TM), [3]CIAO(TM), DAnCE(TM), and [4]CoSMIC(TM) |
| 290 | * (henceforth referred to as "DOC software") are copyrighted by |
| 291 | * [5]Douglas C. Schmidt and his [6]research group at [7]Washington |
| 292 | * University, [8]University of California, Irvine, and [9]Vanderbilt |
| 293 | * University, Copyright (c) 1993-2012, all rights reserved. Since DOC |
| 294 | * software is open-source, freely available software, you are free to |
| 295 | * use, modify, copy, and distribute--perpetually and irrevocably--the |
| 296 | * DOC software source code and object code produced from the source, as |
| 297 | * well as copy and distribute modified versions of this software. You |
| 298 | * must, however, include this copyright statement along with any code |
| 299 | * built using DOC software that you release. No copyright statement |
| 300 | * needs to be provided if you just ship binary executables of your |
| 301 | * software products. |
| 302 | * |
| 303 | * You can use DOC software in commercial and/or binary software releases |
| 304 | * and are under no obligation to redistribute any of your source code |
| 305 | * that is built using DOC software. Note, however, that you may not |
| 306 | * misappropriate the DOC software code, such as copyrighting it yourself |
| 307 | * or claiming authorship of the DOC software code, in a way that will |
| 308 | * prevent DOC software from being distributed freely using an |
| 309 | * open-source development model. You needn't inform anyone that you're |
| 310 | * using DOC software in your software, though we encourage you to let |
| 311 | * [10]us know so we can promote your project in the [11]DOC software |
| 312 | * success stories. |
| 313 | * |
| 314 | * The [12]ACE, [13]TAO, [14]CIAO, [15]DAnCE, and [16]CoSMIC web sites |
| 315 | * are maintained by the [17]DOC Group at the [18]Institute for Software |
| 316 | * Integrated Systems (ISIS) and the [19]Center for Distributed Object |
| 317 | * Computing of Washington University, St. Louis for the development of |
| 318 | * open-source software as part of the open-source software community. |
| 319 | * Submissions are provided by the submitter ``as is'' with no warranties |
| 320 | * whatsoever, including any warranty of merchantability, noninfringement |
| 321 | * of third party intellectual property, or fitness for any particular |
| 322 | * purpose. In no event shall the submitter be liable for any direct, |
| 323 | * indirect, special, exemplary, punitive, or consequential damages, |
| 324 | * including without limitation, lost profits, even if advised of the |
| 325 | * possibility of such damages. Likewise, DOC software is provided as is |
| 326 | * with no warranties of any kind, including the warranties of design, |
| 327 | * merchantability, and fitness for a particular purpose, |
| 328 | * noninfringement, or arising from a course of dealing, usage or trade |
| 329 | * practice. Washington University, UC Irvine, Vanderbilt University, |
| 330 | * their employees, and students shall have no liability with respect to |
| 331 | * the infringement of copyrights, trade secrets or any patents by DOC |
| 332 | * software or any part thereof. Moreover, in no event will Washington |
| 333 | * University, UC Irvine, or Vanderbilt University, their employees, or |
| 334 | * students be liable for any lost revenue or profits or other special, |
| 335 | * indirect and consequential damages. |
| 336 | * |
| 337 | * DOC software is provided with no support and without any obligation on |
| 338 | * the part of Washington University, UC Irvine, Vanderbilt University, |
| 339 | * their employees, or students to assist in its use, correction, |
| 340 | * modification, or enhancement. A [20]number of companies around the |
| 341 | * world provide commercial support for DOC software, however. DOC |
| 342 | * software is Y2K-compliant, as long as the underlying OS platform is |
| 343 | * Y2K-compliant. Likewise, DOC software is compliant with the new US |
| 344 | * daylight savings rule passed by Congress as "The Energy Policy Act of |
| 345 | * 2005," which established new daylight savings times (DST) rules for |
| 346 | * the United States that expand DST as of March 2007. Since DOC software |
| 347 | * obtains time/date and calendaring information from operating systems |
| 348 | * users will not be affected by the new DST rules as long as they |
| 349 | * upgrade their operating systems accordingly. |
| 350 | * |
| 351 | * The names ACE(TM), TAO(TM), CIAO(TM), DAnCE(TM), CoSMIC(TM), |
| 352 | * Washington University, UC Irvine, and Vanderbilt University, may not |
| 353 | * be used to endorse or promote products or services derived from this |
| 354 | * source without express written permission from Washington University, |
| 355 | * UC Irvine, or Vanderbilt University. This license grants no permission |
| 356 | * to call products or services derived from this source ACE(TM), |
| 357 | * TAO(TM), CIAO(TM), DAnCE(TM), or CoSMIC(TM), nor does it grant |
| 358 | * permission for the name Washington University, UC Irvine, or |
| 359 | * Vanderbilt University to appear in their names. |
| 360 | * |
| 361 | * If you have any suggestions, additions, comments, or questions, please |
| 362 | * let [21]me know. |
| 363 | * |
| 364 | * [22]Douglas C. Schmidt |
| 365 | * |
| 366 | * References |
| 367 | * |
| 368 | * 1. http://www.cs.wustl.edu/~schmidt/ACE.html |
| 369 | * 2. http://www.cs.wustl.edu/~schmidt/TAO.html |
| 370 | * 3. http://www.dre.vanderbilt.edu/CIAO/ |
| 371 | * 4. http://www.dre.vanderbilt.edu/cosmic/ |
| 372 | * 5. http://www.dre.vanderbilt.edu/~schmidt/ |
| 373 | * 6. http://www.cs.wustl.edu/~schmidt/ACE-members.html |
| 374 | * 7. http://www.wustl.edu/ |
| 375 | * 8. http://www.uci.edu/ |
| 376 | * 9. http://www.vanderbilt.edu/ |
| 377 | * 10<EMAIL_ADDRESS>|
| 378 | * 11. http://www.cs.wustl.edu/~schmidt/ACE-users.html |
| 379 | * 12. http://www.cs.wustl.edu/~schmidt/ACE.html |
| 380 | * 13. http://www.cs.wustl.edu/~schmidt/TAO.html |
| 381 | * 14. http://www.dre.vanderbilt.edu/CIAO/ |
| 382 | * 15. http://www.dre.vanderbilt.edu/~schmidt/DOC_ROOT/DAnCE/ |
| 383 | * 16. http://www.dre.vanderbilt.edu/cosmic/ |
| 384 | * 17. http://www.dre.vanderbilt.edu/ |
| 385 | * 18. http://www.isis.vanderbilt.edu/ |
| 386 | * 19. http://www.cs.wustl.edu/~schmidt/doc-center.html |
| 387 | * 20. http://www.cs.wustl.edu/~schmidt/commercial-support.html |
| 388 | * 21<EMAIL_ADDRESS>|
| 389 | * 22. http://www.dre.vanderbilt.edu/~schmidt/ |
| 390 | * 23. http://www.cs.wustl.edu/ACE.html |
| 391 | */ |
| 392 | |
| 393 | void |
| 394 | InitializeXPConditionVariable(userland_cond_t *cv) |
| 395 | { |
| 396 | cv->waiters_count = 0; |
| 397 | InitializeCriticalSection(&(cv->waiters_count_lock)); |
| 398 | cv->events_[C_SIGNAL] = CreateEvent (NULL, FALSE, FALSE, NULL); |
| 399 | cv->events_[C_BROADCAST] = CreateEvent (NULL, TRUE, FALSE, NULL); |
| 400 | } |
| 401 | |
| 402 | void |
| 403 | DeleteXPConditionVariable(userland_cond_t *cv) |
| 404 | { |
| 405 | CloseHandle(cv->events_[C_BROADCAST]); |
| 406 | CloseHandle(cv->events_[C_SIGNAL]); |
| 407 | DeleteCriticalSection(&(cv->waiters_count_lock)); |
| 408 | } |
| 409 | |
| 410 | int |
| 411 | SleepXPConditionVariable(userland_cond_t *cv, userland_mutex_t *mtx) |
| 412 | { |
| 413 | int result, last_waiter; |
| 414 | |
| 415 | EnterCriticalSection(&cv->waiters_count_lock); |
| 416 | cv->waiters_count++; |
| 417 | LeaveCriticalSection(&cv->waiters_count_lock); |
| 418 | LeaveCriticalSection (mtx); |
| 419 | result = WaitForMultipleObjects(2, cv->events_, FALSE, INFINITE); |
| 420 | if (result==-1) { |
| 421 | result = GetLastError(); |
| 422 | } |
| 423 | EnterCriticalSection(&cv->waiters_count_lock); |
| 424 | cv->waiters_count--; |
| 425 | last_waiter = result == (C_SIGNAL + C_BROADCAST && (cv->waiters_count == 0)); |
| 426 | LeaveCriticalSection(&cv->waiters_count_lock); |
| 427 | if (last_waiter) |
| 428 | ResetEvent(cv->events_[C_BROADCAST]); |
| 429 | EnterCriticalSection (mtx); |
| 430 | return result; |
| 431 | } |
| 432 | |
| 433 | void |
| 434 | WakeAllXPConditionVariable(userland_cond_t *cv) |
| 435 | { |
| 436 | int have_waiters; |
| 437 | EnterCriticalSection(&cv->waiters_count_lock); |
| 438 | have_waiters = cv->waiters_count > 0; |
| 439 | LeaveCriticalSection(&cv->waiters_count_lock); |
| 440 | if (have_waiters) |
| 441 | SetEvent (cv->events_[C_BROADCAST]); |
| 442 | } |
| 443 | #endif |
| 444 | #endif |
| 445 | |


WINDHORSE (M). (Gil Scrine Films) Directors: Paul Wagner and Thupten Tsering Stars: Dadon, Jampa Kelsang, Richard Chang, Lu Yu, Taije Silverman, Gelek Running time: 97 minutes.
Unlike recent big budget Hollywood productions dealing with Tibet, the low budget Windhorse relentlessly pricks away at the audiences' conscience by exposing the plight of the Tibetan people in the years since the Chinese occupation. Set in contemporary Tibet, Windhorse shows the systematic repression and destruction of the country's religion and culture in the forty years since the Chinese invasion.
This is the first feature film from Oscar winning documentary director Paul Wagner (The Stone Carvers, etc), but it has been largely shaped by his years of documenting unpalatable truths for the camera. Wagner's camera unflinchingly captures the depressing poverty of the capital Lhasa, and depicts the many temples that have been laid to waste. However, the film also captures the resilient spirit and character of the Tibetan people. The title itself comes from the Tibetan tradition of inscribing prayers of hope and freedom on little bits of paper and letting them float through the air. Wagner has also incorporated traditional Tibetan music into the evocative and haunting soundtrack, which further enriches the film.
Unlike the lavish, albeit sanitised Kundun and Seven Years In Tibet, much of Windhorse was actually clandestinely shot inside Tibet itself, using hand held cameras smuggled into Tibet while posing as tourists. Wagner and his crew shot many of the important background locations under the noses of the Chinese security forces, at great personal risk. (The remainder of the film was shot in nearby Kathmandu.) The gritty visual style gives the film a sense of urgency and immediacy missing from those other productions.
Wagner paints a grim picture of contemporary Tibet, one in which the people are constantly watched by the vigilant Chinese, who ruthlessly suppress any hint of rebellion or dissension. Images of the Dalai Lama are forbidden, and the consequences for protest or disobedience are severe. In the past four decades, over one million Tibetans have mysteriously disappeared, or been tortured, murdered or exiled by the Chinese secret police.
Windhorse centres around three twenty something Tibetans who have thus far managed to survive in this dangerous climate by avoiding any sort of conflict with the Chinese authorities. Eighteen years earlier the three witnessed the brutal execution of their grandfather by the Chinese. Although the incident has left deep psychological scars, they have come to believe that any thoughts of resistance are futile. Dolkar (Tibetan singer Dadon) sings karaoke in a night-club, and eventually secures a recording contract singing propaganda for her Chinese masters. Her unemployed brother Dorjee (Jampa Kolsangi) is resentful of the Chinese, but refuses to join the underground resistance movement. Their cousin Pema has become a nun. But when Pema is arrested for daring to protest against the Chinese occupation in a market, Dolkar and Dorjee are finally forced to take action that will forever change their lives.
Windhorse is a confronting, powerfully moving and insightful film that boldly and openly criticises the harsh Chinese regime. Wagner and his co-director Thupten Tsering used a cast and crew comprising of Tibetan exiles, many of whom have withheld their names from the production for fear of Chinese reprisals. This gives a poignancy to their natural and realistic performances, and further adds to the overall feeling of authenticity that permeates the film.
However, the film is not without its technical flaws, most of them a result of Wagner's lack of resources.
*** greg king http://www.netau.com.au/gregking
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


STP_GetBridgePriority
unsigned short STP_GetBridgePriority
(
const STP_BRIDGE* bridge,
unsigned int treeIndex
);
Summary
Reads the bridge priority, that is, the priority component - most significant 4 bits - of
the BridgeIdentifier (§13.26.2 in 802.1Q-2018).
Parameters
- bridge
- Pointer to a STP_BRIDGE object, obtained from
STP_CreateBridge.
- treeIndex
- The zero-based index of the spanning tree for which the bridge priority is to be
returned. For STP or RSTP, this must be zero. For MSTP, this must be zero for the CIST, or
1..64 for an MSTI.
Return value
- The bridge priority. This is a number between 0 and 61440 (0xF000) hex, in steps of 4096
(0x1000 hex).
Remarks
See the Remarks section at STP_SetBridgePriority
for more information about the bridge priority and about the BridgeIndentifier.


--- layout: post title: "DI and events: Third-party Connect" description: "Instead of using Constructor Injection to subscribe to events on a dependency, you can let a third party connect the subscriber to the publisher." date: 2013-09-08 08:08 UTC tags: [Dependency Injection] --- {% include JB/setup %}
{{ page.description }}
In the previous article in my series about Dependency Injection and events, you saw an example of how injecting a dependency that raises events violates Nikola Malovic's 4th law of IoC: Injection Constructors should perform no work.
In this article, you'll see the first of several alternatives.
Take a step back and recall why you're using Dependency Injection in the first place. Hopefully, you use Dependency Injection because it provides the decoupling necessary to make your code more maintainable (and thus, you and your colleagues more productive). However, events are already a mechanism for decoupling. In .NET, events are simply a (limited) baked-in implementation of the Observer pattern.
Perhaps it's helpful if we consider alternative names for Dependency Injection. Nat Pryce prefers the term Third-party Connect, and I think that there's much sense in that name. Instead of focusing on the injection part, or even Inversion of Control, the term Third-party Connect focuses on the fact that when you decouple two objects, you need a third party to connect them with each other. In a well-designed application, this third party will often be the Composition Root.
If you already have a third party connecting NeedyClass with IDependency, must you use Constructor Injection?
Apparently, if you consider the code in the previous article, NeedyClass is required to do something whenever a particular IDependency instance raises its ItHappened event. What if, instead of injecting IDependency and subscribing a private event handler, you were to expose a public method that implements the same logic as that private event handler?
public class NeedyClass { public void DoSomethingInteresting() { // Handle event here } }
Notice how much simpler this implementation is, compared with the previous version. Nothing is injected, there are no interfaces in play. Such a class is very easy to unit test as well, so I think this looks very promising.
Doesn't this design break encapsulation? Not more than before. Remember, in the previous implementation, you could always inject an implementation of IDependency that enabled you to raise the ItHappened event, and thereby invoke the private event handler in NeedyClass. This new design just makes it a bit easier to invoke the method. Keep in mind that encapsulation isn't about public versus private members; encapsulation is about invariants.
This version of NeedyClass doesn't actually expose a public 'event handler', since the DoSomethingInteresting method doesn't match the event handler signature. Thus, if you use a static code analysis tool, it's not going to complain about a public event handler. The DoSomethingInteresting method is a method just like any other method. This design is much more decoupled than before, because NeedyClass knows nothing about IDependency. Hopefully, it makes sense as a stand-alone class with its own API. This makes it more reusable.
At this point, NeedyClass is no longer an appropriate name, but let's keep it for now.
In order to connect NeedyClass with IDependency, the third party (e.g. the Composition Root) can subscribe the DoSomethingInteresting method to the ItHappened event:
var nc = new NeedyClass(); dependency.ItHappened += (s, e) => nc.DoSomethingInteresting();
The advantage of this design is that it's much more decoupled than before.  However, one disadvantage is that it's easy to forget to connect these two objects with each other; the compiler no longer offers any help.
If both objects are long-lived objects (i.e. have the Singleton lifetime style), you probably only need to write and invoke that connection code once, in the Composition Root. In this case, one or two Smoke Tests should prevent any regressions.
However, if one or both of these objects have shorter lifetimes, you may want to encapsulate the creation of NeedyClass in some sort of Factory. Still, unless you make the NeedyClass constructor internal or private, programmers may forget to use the Factory, so this can still be a fragile solution.
Another problem that this Third-party Connect solution shares with Constructor Subscription is that you still need to think about disconnecting the two objects, once you're done with them. This isn't hard to do.
EventHandler handler = (s, e) => nc.DoSomethingInteresting(); dependency.ItHappened += handler; // Do something interesting here dependency.ItHappened -= handler;
While not particularly difficult, it does require you to take the extra step of assigning the event handler to a variable you can later use to unsubscribe. Still, the worst part of this attempt at a solution is probably that, just like you'll need to remember to subscribe NeedyClass to the event, you must also remember to unsubscribe it. At least, in this case, there's a better symmetry, because you must remember to both subscribe and unsubscribe, whereas with Constructor Subscription, you only needed to remember to unsubscribe (or dispose, as it were).
Using Third-party Connect leads to a simpler, but more Fragile design. Still, I often find that the extreme simplicity of the involved classes trumps the fragility of the design; if I had to choose between Third-party Connect and Constructor Subscription, I'd select Third-party Connect. Fortunately, these aren't the only options available to you; in future articles, I'll approach a better alternative.


--- notes: | ### Field Labels (Standard) Field labels will be displayed adjacent to their corresponding fields. Clicking a field label will focus the associated input field which can be achieved through use of for/id attributes. --- First Name ZIP Code


I am aspiring to be a Computer Scientist, when I first found out about coding I instantly got hooked.
The following are a list of things I know about coding:


--- layout: posts title: Restaurants permalink: /restaurants/ description: Posts by restaurants --- {% include group-by-array.html collection=site.posts field="restaurant" %}


algorithms
programming
How to contribute your inputs to the Adaptive Sorting Benchmark
If you consider contributing sorted lists from your own Python application to our benchmark for adaptive sorting, the steps below show you how to do collect this data. Note: Our instrumentation stores a list of integers with equivalent comparison-behavior to all lists sorted when running Python code through our custom CPython.
Background
The goal of the benchmark is to collect real-world data from Python applications
to better understand the effectiveness of adaptive features in the list sort functions.
In my PyCon US 2023 talk, I reached out to Pythonistas to contribute their sorting inputs.
If sorted lists were completely random data, we would never see (significant) improvements
from these, but data hardly is very random.
How much pre-sortedness is there in your use case? Let’s find out!
Step 1: Build instrumented CPython
Clone the instrumented branch of CPython; currently we have support for 3.11 or 3.10. (If we dearly need another version, drop me a line and we can add it.)
git clone https://github.com/sebawild/cpython --branch 3.11-instrumented --single-branch cpython-sorting
cd cpython-sorting
The steps below assume linux and a set up development environment;
check the official instructions).
For a core installation only standard C build tools are needed, plus OpenSSL headers.
(On Ubuntu, you get the latter via sudo apt-get install libssl-dev
).
./configure --enable-optimizations && make -j
make test
Step 2: Set up your project
First, we create a venv (a virtual environment to keep installed package local).
Inside cpython-sorting
, call
./python -m venv sorting-python
source sorting-python/bin/activate
to create and activate the sorting-python
venv.
Now you can use pip in the usual way to install any needed packages.
Step 3: Run your application and submit arrays.txt
You run your application as normal: python your-awesome-script.py
.
To collect the benchmark data, first delete arrays.txt
(results are otherwise appended)
and run your application.
Then store arrays.txt
and send it over,
with a quick description of your application.
Afterwards arrays.txt
will contain all sorted lists (and some stats).
Note that even during the process of starting python, a few dozen calls to list sort
are made (mostly on tiny lists); for the benchmark, we are mostly interested in
big lists.
A rudimentary script to read an arrays.txt
file and compute some presortedness
metrics is implemented in run-information.py
.
Simply running python run-information.py
(in the same folder) will
print stats on the longest sorted list (by default).
This is sufficient to check whether your application sorted substantially long list at all.
If so, please send your arrays.txt
to me.
Limitations
The instrumentation is a quick hack at this point, not production-ready code. It is hence best to run code via our python in a sandbox environment.
Known limitations:
- The output
arrays.txt
is appended each time you runpython
and it could grow large. - Our instrumentation is not ready for multi-threading. T* he instrumentation may crash python in obscure scenarios such as comparison functions that modify the sorted list.


coming soon........
Subscribe now to our monthly newsletter for Americor specials, rate updates and industry news. We
will not
share your email address with any third parties.
.


Toggle navigation
RAW
Home
About
Contact
Welcome to RAW
TODO: One-line summary. Close (X) button.
Learn more »
Code
#example interactive data viewing t1 = csv('employees.csv') sql('select * from tbl where a > 5', tbl=t1)
Data
Site built by ...
Click to Subscribe for more info...


Looking for Covid-related info?
Find relevant, reliable information here:
-
General
-
Vaccines
-
Travel


Named Entity Recognition
Using RoBERTa
Type your sentence:
{{ form.csrf_token }} {{ form.sentence_for_ner(class="form-control", rows="5") }}


--- layout: docpage title: "Documentation" is_homepage: false is_sphinx_doc: true doc-parent: "Cassandra Development" doc-title: "How-to Commit" doc-header-links: ' ' doc-search-path: "../search.html" extra-footer: ' ' ---
If you are a committer, feel free to pick any process that works for you - so long as you are planning to commit the work yourself.
Here is how committing and merging will usually look for merging and pushing for tickets that follow the convention (if patch-based):
Hypothetical CASSANDRA-12345 ticket is a cassandra-3.0 based bug fix that requires different code for cassandra-3.3, and trunk. Contributor Jackie supplied a patch for the root branch (12345-3.0.patch), and patches for the remaining branches (12345-3.3.patch, 12345-trunk.patch).
git am -3 12345-3.0.patch
(if we have a problem b/c of CHANGES.txt not merging anymore, we fix it ourselves, in place)git merge cassandra-3.0 -s ours
git apply -3 12345-3.3.patch
(likely to have an issue with CHANGES.txt here: fix it ourselves, then git add CHANGES.txt)git commit —amend
git merge cassandra-3.3 -s ours
git apply -3 12345-trunk.patch
(likely to have an issue with CHANGES.txt here: fix it ourselves, then git add CHANGES.txt)git commit —amend
git push origin cassandra-3.0 cassandra-3.3 trunk —atomic
Same scenario, but a branch-based contribution:
git cherry-pick <sha-of-3.0-commit>
(if we have a problem b/c of CHANGES.txt not merging anymore, we fix it ourselves, in place)git merge cassandra-3.0 -s ours
git format-patch -1 <sha-of-3.3-commit>
git apply -3 <sha-of-3.3-commit>.patch
(likely to have an issue with CHANGES.txt here: fix it ourselves, then git add CHANGES.txt)git commit —amend
git merge cassandra-3.3 -s ours
git format-patch -1 <sha-of-trunk-commit>
git apply -3 <sha-of-trunk-commit>.patch
(likely to have an issue with CHANGES.txt here: fix it ourselves, then git add CHANGES.txt)git commit —amend
git push origin cassandra-3.0 cassandra-3.3 trunk —atomic
Tip
Notes on git flags:
-3
flag to am and apply will instruct git to perform a 3-way merge for you. If a conflict is detected, you can either resolve it manually or invoke git mergetool - for both am and apply.
—atomic
flag to git push does the obvious thing: pushes all or nothing. Without the flag, the command is equivalent to running git push once per each branch. This is nifty in case a race condition happens - you won’t push half the branches, blocking other committers’ progress while you are resolving the issue.
Tip
The fastest way to get a patch from someone’s commit in a branch on GH - if you don’t have their repo in remotes - is to append .patch to the commit url, e.g. curl -O https://github.com/apache/cassandra/commit/7374e9b5ab08c1f1e612bf72293ea14c959b0c3c.patch


... # draw to the canvas export("spool.pdf", cmyk=False)
... # draw at retina-quality to the canvas export("spool.png", zoom=2)
with export("movie.mov", fps=30, bitrate=1.0): ... # draw movie frames
with export("anim.gif", fps=30, loop=0): ... # draw gif frames
The export() command allows you to generate images and animations from within your scripts. Calling export() as part of a with
statement will allow you to render single images, multi-page sequences, or animations.
When running the PlotDevice application, you'll likely find it more convenient to use the standalone scripts that import the plotdevice
module, the export() command is the main avenue for generating graphics.
You can call export() at any time to write the current set of graphics objects on the canvas to a single bitmap or vector image file. The only required argument is a file path (whose extension will determine the format). The optional cmyk
argument can be set to True
to use "process" colors when exporting to a PDF, EPS, or TIFF file.
By default, bitmap images will be exported at 1:1 resolution (i.e., one pixel for each ‘point’ in the area set via size()). The zoom
parameter defaults to 1.0
and allows you to generate arbitrarily larger (or smaller) magnifications—though sticking to round numbmers like 1, 2, and 3 will give you the best results. As a shortcut, you can also set your filename to end with an "@…x"
to specify the zoom factor.
For instance the following will generate identical bitmaps:
export("retina.png", zoom=2<EMAIL_ADDRESS>The export() command returns a context manager that takes care of canvas-setup and file-generation for both single images and animations. By enclosing your drawing code in a with
block, you can ensure that the correct sequence of clear() and export() calls is made automatically.
For instance these two methods of generating a PNG are functionally equivalent:
clear(all) ... # (do some drawing) export('output.png') # let the context manager handle clearing and saving the canvas automatically with export('output.png'): ... # (do some drawing)
If you specify a filename ending in mov
(or gif
if you also pass a loop
or fps
argument), the export() command will begin a multi-frame animation and return an object to help you coordinate things. You can "capture" this object and give it a name (for instance, movie
) using Python's "with … as …" syntax.
Each time you call the movie
's add() method, a new frame with the contents of the canvas will be added to the end of the animation. Once you’ve added the movie
's final frame, you must call the finish() method to wait for the video encoder's background thread to complete its work.
As with the single-image version of the export() call, you can use the with
statement in your code to tidy up some of the frame-drawing boilerplate. All three examples below are equivalent. Note the use of the movie
object's frame property (which is itself a context manager) in the final example:
# export a 100-frame movie movie = export('anim.mov', fps=50, bitrate=1.8) for i in range(100): clear(all) # erase the previous frame from the canvas ... # (do some drawing) movie.add() # add the canvas to the movie movie.finish() # wait for i/o to complete
# export a movie (with the context manager finishing the file when done) with export('anim.mov', fps=50, bitrate=1.8) as movie: for i in range(100): clear(all) # erase the previous frame from the canvas ... # (do some drawing) movie.add() # add the canvas to the movie
# export a movie (with the context manager finishing the file when done) # let the movie.frame context manager call clear() and add() for us with export('anim.mov', fps=50, bitrate=1.8) as movie: for i in range(100): with movie.frame: ... # draw the next frame
If you’re generating a series of static images, export() will automatically give them consecutive names derived from the filename you pass as an argument. If the filename is a simple "name.ext"
string, the sequence number will be appended with 4 characters of padding ("name-0001.ext"
, "name-0002.ext"
, etc.).
If the filename contains a number between curly braces (e.g., "name-{4}.ext"
), that substring will be replaced with the sequence number and zero padded to the specified number of digits:
# export a sequence of images to output-0001.png, output-0002.png, ... # output-0099.png, output-0100.png with export('output.png') as img: for i in range(100): with img.frame: ... # draw the next image in the sequence # export a sequence of images to 01-img.png, 02-img.png, ... # 99-img.png, 100-img.png with export('{2}-img.png') as img: for i in range(100): with img.frame: ... # draw the next image in the sequence
Creating PDF documents works the same way, letting you either clear(), add(), and finish() the export manually or take advantage of the with
statement to hide the repetitive bits. Note that PDF exports use the page
attribute rather than frame
:
# export a five-page pdf document pdf = export('multipage.pdf') for i in range(5): clear(all) # erase the previous page's graphics from the canvas ... # (do some drawing) pdf.add() # add the canvas to the pdf as a new page pdf.finish() # write the pdf document to disk # export a pdf document more succinctly with export('multipage.pdf') as pdf: for i in range(5): with pdf.page: ... # draw the next page


---
layout: default
permalink: /
---
Welcome to WashU WiCS!
Washington University Women in Computer Science’s mission is to create a welcoming and supportive community for women in computing, bolster professional development by providing networking and mentorship opportunities, and inspire future generations of women by giving back to the greater St. Louis community.
About Us
- Here at WashU, our Women in Computer Science organization brings together women all across campus with an interest in technology.
- WiCS hosts a variety of professional development events, including tech talks from top employers, company information sessions, and technical interview prep workshops.
- WiCS also connects members with exciting social events, like welcome-back socials, a WiCS&Mix outing, and a mentorship day.


{% extends "layout.html" %} {% block title %} {{_('Admin')}} {% endblock %} {% block content %}
| User | Eligible | Filled | Unanswered | |
|---|---|---|---|---|
| {{ participation.description.user.email }} | {{ participation.eligible }} | {{ participation.description.is_filled }} | {{ participation.description.unanswered }} | Remove Participation |
There is currently no active round!
{% endif %}| ID | Created at | Questions |
|---|---|---|
| {{ round.id }} | {{ round.created_at }} | TODO |
There no former rounds.
{% endif %}| Text | Type |
|
|
|---|---|---|---|
| {{ question.text }} | {{ question.q_type }} | {% if question.in_cur_round %}Use Question{% else %}Don't Use Question{% endif %} | Delete Question |
| Id | Admin |
|
|---|---|---|
| {{ user.email }} | Toggle Admin | Remove User |


|
|
typedef TP | BeLePolicy |
| |
|
typedef TP::U16 | TE16 |
| |
|
typedef TP::U32 | TE32 |
| |
|
typedef TP::U64 | TE64 |
| |
|
typedef N_Mach::MachITypes< TE32, TE64, TE32, TE32 > | MachITypes |
| |
|
typedef MachITypes::Addr | Addr |
| |
|
typedef N_Mach::Mach_header< MachITypes > | Mach_header |
| |
|
typedef N_Mach::Mach_command< MachITypes > | Mach_command |
| |
|
typedef N_Mach::Mach_segment_command< MachITypes > | Mach_segment_command |
| |
|
typedef N_Mach::Mach_section_command< MachITypes > | Mach_section_command |
| |
|
typedef N_Mach::Mach_symtab_command< MachITypes > | Mach_symtab_command |
| |
|
typedef N_Mach::Mach_dysymtab_command< MachITypes > | Mach_dysymtab_command |
| |
|
typedef N_Mach::Mach_segsplit_info_command< MachITypes > | Mach_segsplit_info_command |
| |
|
typedef N_Mach::Mach_routines_command< MachITypes > | Mach_routines_command |
| |
|
typedef N_Mach::Mach_twolevel_hints_command< MachITypes > | Mach_twolevel_hints_command |
| |
|
typedef N_Mach::Mach_linkedit_data_command< MachITypes > | Mach_linkedit_data_command |
| |
|
typedef N_Mach::Mach_uuid_command< MachITypes > | Mach_uuid_command |
| |
|
typedef N_Mach::Mach_data_in_code_command< MachITypes > | Mach_data_in_code_command |
| |
|
typedef N_Mach::Mach_function_starts_command< MachITypes > | Mach_function_starts_command |
| |
|
typedef N_Mach::Mach_load_dylib_command< MachITypes > | Mach_load_dylib_command |
| |
|
typedef N_Mach::Mach_dylib< MachITypes > | Mach_dylib |
| |
|
typedef N_Mach::Mach_load_dylinker_command< MachITypes > | Mach_load_dylinker_command |
| |
|
typedef N_Mach::Mach_dyld_info_only_command< MachITypes > | Mach_dyld_info_only_command |
| |
|
typedef N_Mach::Mach_version_min_command< MachITypes > | Mach_version_min_command |
| |
|
typedef N_Mach::Mach_source_version_command< MachITypes > | Mach_source_version_command |
| |
|
typedef N_Mach::Mach_main_command< MachITypes > | Mach_main_command |
| |
|
typedef N_Mach32::Mach_ppc_thread_state< MachITypes > | Mach_ppc_thread_state |
| |
|
typedef N_Mach32::Mach_i386_thread_state< MachITypes > | Mach_i386_thread_state |
| |
|
typedef N_Mach32::Mach_ARM_thread_state< MachITypes > | Mach_ARM_thread_state |
| |