ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.toRatCDF_unit_prod
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
a : α
⊢ toRatCDF (fun p => f p.2) ((), a) = toRatCDF f a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
a : α
⊢ (if IsRatStieltjesPoint (fun p => f p.2) ((), a) then (fun p => f p.2) ((), a) else defaultRatCDF) =
    if IsRatStieltjesPoint f a then f a else defaultRatCDF
tactic: unfold toRatCDF
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
a : α
⊢ (if IsRatStieltjesPoint (fun p => f p.2) ((), a) then (fun p => f p.2) ((), a) else defaultRatCDF) =
    if IsRatStieltjesPoint f a then f a else defaultRatCDF
state_after: no goals
tactic: rw [isRatStieltjesPoint_unit_prod_iff]
Theorem: LieSubmodule.map_incl_le
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ N
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ map N.incl ⊤
tactic: conv_rhs => rw [← N.map_incl_top]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
N' : LieSubmodule R L ↥↑N
⊢ map N.incl N' ≤ map N.incl ⊤
state_after: no goals
tactic: exact LieSubmodule.map_mono le_top
Theorem: RCLike.conj_eq_iff_real
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ (∃ r, ↑r = z) ↔ ∃ r, z = ↑r
state_after: no goals
tactic: simp only [eq_comm]
Theorem: bddBelow_closure
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : ClosedIciTopology α
f : β → α
a b : α
s : Set α
⊢ BddBelow (closure s) ↔ BddBelow s
state_after: no goals
tactic: simp_rw [BddBelow, lowerBounds_closure]
Theorem: Sum.getRight_eq_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: β✝ : Type u_1
b : β✝
α✝ : Type u_2
x : α✝ ⊕ β✝
h : x.isRight = true
⊢ x.getRight h = b ↔ x = inr b
state_after: no goals
tactic: cases x <;> simp at h ⊢
Theorem: Turing.Tape.map_move
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
T : Tape Γ
d : Dir
⊢ map f (move d T) = move d (map f T)
state_after: case mk
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
d : Dir
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ map f (move d { head := head✝, left := left✝, right := right✝ }) =
    move d (map f { head := head✝, left := left✝, right := right✝ })
tactic: cases T
state_before: case mk
Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
d : Dir
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ map f (move d { head := head✝, left := left✝, right := right✝ }) =
    move d (map f { head := head✝, left := left✝, right := right✝ })
state_after: no goals
tactic: cases d <;> simp only [Tape.move, Tape.map, ListBlank.head_map, eq_self_iff_true,
    ListBlank.map_cons, and_self_iff, ListBlank.tail_map]
Theorem: MeasureTheory.union_cylinder
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
⊢ cylinder s₁ S₁ ∪ cylinder s₂ S₂ = cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)
state_after: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ f ∈ cylinder s₁ S₁ ∪ cylinder s₂ S₂ ↔
    f ∈ cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)
tactic: ext1 f
state_before: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ f ∈ cylinder s₁ S₁ ∪ cylinder s₂ S₂ ↔
    f ∈ cylinder (s₁ ∪ s₂) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂)
state_after: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ (fun i => f ↑i) ∈ S₁ ∨ (fun i => f ↑i) ∈ S₂ ↔
    (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∨ (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂
tactic: simp only [mem_union, mem_cylinder, mem_setOf_eq]
state_before: case h
ι : Type u_1
α : ι → Type u_2
s₁ s₂ : Finset ι
S₁ : Set ((i : { x // x ∈ s₁ }) → α ↑i)
S₂ : Set ((i : { x // x ∈ s₂ }) → α ↑i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
⊢ (fun i => f ↑i) ∈ S₁ ∨ (fun i => f ↑i) ∈ S₂ ↔
    (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∨ (fun i => f ↑i) ∈ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂
state_after: no goals
tactic: rfl
Theorem: Multiset.mem_powersetCard
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
n : ℕ
s t : Multiset α
l : List α
⊢ s ∈ powersetCard n ⟦l⟧ ↔ s ≤ ⟦l⟧ ∧ card s = n
state_after: no goals
tactic: simp [powersetCard_coe']
Theorem: AddSubmonoid.nsmul_vadd_mem_closure_vadd
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝⁴ : Monoid M
inst✝³ : AddMonoid A
s✝ t u : Set M
N : Type u_6
inst✝² : CommMonoid N
inst✝¹ : MulAction M N
inst✝ : IsScalarTower M N N
r : M
s : Set N
x : N
hx : x ∈ closure s
⊢ ∃ n, r ^ n • x ∈ closure (r • s)
state_after: case refine_1
α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝⁴ : Monoid M
inst✝³ : AddMonoid A
s✝ t u : Set M
N : Type u_6
inst✝² : CommMonoid N
inst✝¹ : MulAction M N
inst✝ : IsScalarTower M N N
r : M
s : Set N
x : N
hx : x ∈ closure s
⊢ ∀ x ∈ s, (fun x => ∃ n, r ^ n • x ∈ closure (r • s)) x

case refine_2
α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝⁴ : Monoid M
inst✝³ : AddMonoid A
s✝ t u : Set M
N : Type u_6
inst✝² : CommMonoid N
inst✝¹ : MulAction M N
inst✝ : IsScalarTower M N N
r : M
s : Set N
x : N
hx : x ∈ closure s
⊢ (fun x => ∃ n, r ^ n • x ∈ closure (r • s)) 1

case refine_3
α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝⁴ : Monoid M
inst✝³ : AddMonoid A
s✝ t u : Set M
N : Type u_6
inst✝² : CommMonoid N
inst✝¹ : MulAction M N
inst✝ : IsScalarTower M N N
r : M
s : Set N
x : N
hx : x ∈ closure s
⊢ ∀ (x y : N),
    (fun x => ∃ n, r ^ n • x ∈ closure (r • s)) x →
      (fun x => ∃ n, r ^ n • x ∈ closure (r • s)) y → (fun x => ∃ n, r ^ n • x ∈ closure (r • s)) (x * y)
tactic: refine @closure_induction N _ s (fun x : N => ∃ n : ℕ, r ^ n • x ∈ closure (r • s)) _ hx ?_ ?_ ?_
Theorem: not_mem_closure_iff_nhdsWithin_eq_bot
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ x ∉ closure s ↔ 𝓝[s] x = ⊥
state_after: no goals
tactic: rw [mem_closure_iff_nhdsWithin_neBot, not_neBot]
Theorem: Set.encard_eq_zero
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ s.encard = 0 ↔ s = ∅
state_after: no goals
tactic: rw [encard, ← PartENat.withTopEquiv.symm.injective.eq_iff, Equiv.symm_apply_apply,
    PartENat.withTopEquiv_symm_zero, PartENat.card_eq_zero_iff_empty, isEmpty_subtype,
    eq_empty_iff_forall_not_mem]
Theorem: Rat.mkRat_nonneg
File: Mathlib/Algebra/Order/Ring/Rat.lean

Proof steps:
state_before: a✝ b✝ c p q : ℚ
a : ℤ
ha : 0 ≤ a
b : ℕ
⊢ 0 ≤ mkRat a b
state_after: no goals
tactic: simpa using divInt_nonneg ha (Int.natCast_nonneg _)
Theorem: Equiv.Set.union_symm_apply_left
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β : Sort v
γ : Sort w
α : Type ?u.15873
s t : Set α
inst✝ : DecidablePred fun x => x ∈ s
H : s ∩ t ⊆ ∅
a : ↑s
⊢ ↑a ∈ s ∪ t
state_after: no goals
tactic: simp
Theorem: Lists.Equiv.symm
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
l₁ l₂ : Lists α
h : l₁ ~ l₂
⊢ l₂ ~ l₁
state_after: no goals
tactic: cases' h with _ _ _ h₁ h₂ <;> [rfl; exact Equiv.antisymm h₂ h₁]