ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: finprod_curry₃
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
⊢ ∏ᶠ (abc : α × β × γ), f abc = ∏ᶠ (a : α) (b : β) (c : γ), f (a, b, c)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
⊢ ∏ᶠ (a : α) (b : β × γ), f (a, b) = ∏ᶠ (a : α) (b : β) (c : γ), f (a, b, c)
tactic: rw [finprod_curry f h]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
⊢ ∏ᶠ (a : α) (b : β × γ), f (a, b) = ∏ᶠ (a : α) (b : β) (c : γ), f (a, b, c)
state_after: case e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
⊢ (fun a => ∏ᶠ (b : β × γ), f (a, b)) = fun a => ∏ᶠ (b : β) (c : γ), f (a, b, c)
tactic: congr
state_before: case e_f
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
⊢ (fun a => ∏ᶠ (b : β × γ), f (a, b)) = fun a => ∏ᶠ (b : β) (c : γ), f (a, b, c)
state_after: case e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
a : α
⊢ ∏ᶠ (b : β × γ), f (a, b) = ∏ᶠ (b : β) (c : γ), f (a, b, c)
tactic: ext a
state_before: case e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
a : α
⊢ ∏ᶠ (b : β × γ), f (a, b) = ∏ᶠ (b : β) (c : γ), f (a, b, c)
state_after: case e_f.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
a : α
⊢ (mulSupport fun b => f (a, b)).Finite
tactic: rw [finprod_curry]
state_before: case e_f.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
γ : Type u_7
f : α × β × γ → M
h : (mulSupport f).Finite
a : α
⊢ (mulSupport fun b => f (a, b)).Finite
state_after: no goals
tactic: simp [h]
Theorem: Lists'.to_ofList
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
l : List (Lists α)
⊢ (ofList l).toList = l
state_after: no goals
tactic: induction l <;> simp [*]
Theorem: Ideal.span_pair_mul_span_pair
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
w x y z : R
⊢ span {w, x} * span {y, z} = span {w * y, w * z, x * y, x * z}
state_after: no goals
tactic: simp_rw [span_insert, sup_mul, mul_sup, span_singleton_mul_span_singleton, sup_assoc]
Theorem: Quotient.eq_mk_iff_out
File: Mathlib/Data/Quot.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ x.out ≈ y
state_after: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ ⟦x.out⟧ = ⟦y⟧
tactic: refine Iff.trans ?_ Quotient.eq
state_before: α : Sort u_1
β : Sort u_2
s : Setoid α
x : Quotient s
y : α
⊢ x = ⟦y⟧ ↔ ⟦x.out⟧ = ⟦y⟧
state_after: no goals
tactic: rw [Quotient.out_eq x]
Theorem: Set.powerset_insert
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
⊢ 𝒫 insert a s = 𝒫 s ∪ insert a '' 𝒫 s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ t ∈ 𝒫 insert a s ↔ t ∈ 𝒫 s ∪ insert a '' 𝒫 s
tactic: ext t
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ t ∈ 𝒫 insert a s ↔ t ∈ 𝒫 s ∪ insert a '' 𝒫 s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ t ⊆ insert a s ↔ t ⊆ s ∨ ∃ x ⊆ s, insert a x = t
tactic: simp_rw [mem_union, mem_image, mem_powerset_iff]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ t ⊆ insert a s ↔ t ⊆ s ∨ ∃ x ⊆ s, insert a x = t
state_after: case h.mp
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ t ⊆ insert a s → t ⊆ s ∨ ∃ x ⊆ s, insert a x = t

case h.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
s : Set α
a : α
t : Set α
⊢ (t ⊆ s ∨ ∃ x ⊆ s, insert a x = t) → t ⊆ insert a s
tactic: constructor
Theorem: LieModule.chainTopCoeff_add_one
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ chainTopCoeff α β + 1 = Nat.find ⋯
state_after: no goals
tactic: classical
  rw [chainTopCoeff, dif_neg hα]
  apply Nat.succ_pred_eq_of_pos
  rw [zero_lt_iff]
  intro e
  have : weightSpace M (0 • α + β : L → R) = ⊥ := by
    rw [← e]
    exact Nat.find_spec (eventually_weightSpace_smul_add_eq_bot M α β hα).exists
  exact β.weightSpace_ne_bot _ (by simpa only [zero_smul, zero_add] using this)
Theorem: Unitization.splitMul_apply
File: Mathlib/Analysis/Normed/Algebra/Unitization.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : Unitization 𝕜 A
⊢ (x.fst + 0, (lift (NonUnitalAlgHom.Lmul 𝕜 A)).toRingHom x) =
    (x.fst, (algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd)
state_after: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : Unitization 𝕜 A
⊢ (x.fst, (lift (NonUnitalAlgHom.Lmul 𝕜 A)).toRingHom x) = (x.fst, (algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd)
tactic: rw [add_zero]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : Unitization 𝕜 A
⊢ (x.fst, (lift (NonUnitalAlgHom.Lmul 𝕜 A)).toRingHom x) = (x.fst, (algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd)
state_after: no goals
tactic: rfl
Theorem: FractionalIdeal.spanSingleton_mul_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : K
hx : x ≠ 0
⊢ spanSingleton R₁⁰ x * (spanSingleton R₁⁰ x)⁻¹ = 1
state_after: no goals
tactic: rw [spanSingleton_inv, spanSingleton_mul_spanSingleton, mul_inv_cancel hx, spanSingleton_one]
Theorem: Ideal.map_includeLeft_eq
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal A
⊢ Submodule.restrictScalars R (map includeLeft I) =
    LinearMap.range (LinearMap.rTensor B (Submodule.restrictScalars R I).subtype)
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal A
⊢ (Submodule.restrictScalars R (map includeLeft I)).carrier =
    (LinearMap.range (LinearMap.rTensor B (Submodule.restrictScalars R I).subtype)).carrier
tactic: rw [← Submodule.carrier_inj]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal A
⊢ (Submodule.restrictScalars R (map includeLeft I)).carrier =
    (LinearMap.range (LinearMap.rTensor B (Submodule.restrictScalars R I).subtype)).carrier
state_after: case a
R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal A
⊢ (Submodule.restrictScalars R (map includeLeft I)).carrier ≤
    (LinearMap.range (LinearMap.rTensor B (Submodule.restrictScalars R I).subtype)).carrier

case a
R : Type u_1
inst✝⁴ : CommSemiring R
A : Type u_2
B : Type u_3
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
I : Ideal A
⊢ (LinearMap.range (LinearMap.rTensor B (Submodule.restrictScalars R I).subtype)).carrier ≤
    (Submodule.restrictScalars R (map includeLeft I)).carrier
tactic: apply le_antisymm
Theorem: Nat.Prime.dvd_iff_eq
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n p a : ℕ
hp : Prime p
a1 : a ≠ 1
⊢ a ∣ p ↔ p = a
state_after: n p a : ℕ
hp : Prime p
a1 : a ≠ 1
⊢ a ∣ p → p = a
tactic: refine ⟨?_, by rintro rfl; rfl⟩
state_before: n p a : ℕ
hp : Prime p
a1 : a ≠ 1
⊢ a ∣ p → p = a
state_after: case intro
n a : ℕ
a1 : a ≠ 1
j : ℕ
hp : Prime (a * j)
⊢ a * j = a
tactic: rintro ⟨j, rfl⟩
state_before: case intro
n a : ℕ
a1 : a ≠ 1
j : ℕ
hp : Prime (a * j)
⊢ a * j = a
state_after: case intro.inl.intro
n a : ℕ
a1 : a ≠ 1
left✝ : Prime a
hp : Prime (a * 1)
⊢ a * 1 = a

case intro.inr.intro
n j : ℕ
left✝ : Prime j
a1 : 1 ≠ 1
hp : Prime (1 * j)
⊢ 1 * j = 1
tactic: rcases prime_mul_iff.mp hp with (⟨_, rfl⟩ | ⟨_, rfl⟩)
Theorem: OrderEmbedding.image_Icc
File: Mathlib/Order/Interval/Set/OrdConnected.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ↪o β
he : (range ⇑e).OrdConnected
x y : α
⊢ ⇑e '' Icc x y = Icc (e x) (e y)
state_after: no goals
tactic: rw [← e.preimage_Icc, image_preimage_eq_inter_range, inter_eq_left.2 (he.out ⟨_, rfl⟩ ⟨_, rfl⟩)]
Theorem: SimpleGraph.Subgraph.subgraphOfAdj_connected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
⊢ (G.subgraphOfAdj hvw).Connected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
⊢ (G.subgraphOfAdj hvw).coe.Preconnected
tactic: refine ⟨⟨?_⟩⟩
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
⊢ (G.subgraphOfAdj hvw).coe.Preconnected
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
a : V
ha : a ∈ (G.subgraphOfAdj hvw).verts
b : V
hb : b ∈ (G.subgraphOfAdj hvw).verts
⊢ (G.subgraphOfAdj hvw).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
a : V
ha : a ∈ (G.subgraphOfAdj hvw).verts
b : V
hb : b ∈ (G.subgraphOfAdj hvw).verts
⊢ (G.subgraphOfAdj hvw).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
a : V
ha✝ : a ∈ (G.subgraphOfAdj hvw).verts
b : V
hb✝ : b ∈ (G.subgraphOfAdj hvw).verts
ha : a = v ∨ a = w
hb : b = v ∨ b = w
⊢ (G.subgraphOfAdj hvw).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩
tactic: simp only [subgraphOfAdj_verts, Set.mem_insert_iff, Set.mem_singleton_iff] at ha hb
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v w : V
hvw : G.Adj v w
a : V
ha✝ : a ∈ (G.subgraphOfAdj hvw).verts
b : V
hb✝ : b ∈ (G.subgraphOfAdj hvw).verts
ha : a = v ∨ a = w
hb : b = v ∨ b = w
⊢ (G.subgraphOfAdj hvw).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩
state_after: no goals
tactic: obtain rfl | rfl := ha <;> obtain rfl | rfl := hb <;>
    first | rfl | (apply Adj.reachable; simp)
Theorem: skyscraperPresheafCoconeOfSpecializes_ι_app
File: Mathlib/Topology/Sheaves/Skyscraper.lean

Proof steps:
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A).map inc ≫ (fun U => eqToHom ⋯) V =
    (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc
state_after: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ (if h : p₀ ∈ unop ((OpenNhds.inclusion y).op.obj V) then eqToHom ⋯
      else
        (⋯ ▸ terminalIsTerminal).from ((fun U => if p₀ ∈ unop U then A else ⊤_ C) ((OpenNhds.inclusion y).op.obj U))) ≫
      (fun U => eqToHom ⋯) V =
    (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc
tactic: change dite _ _ _ ≫ _ = _
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ (if h : p₀ ∈ unop ((OpenNhds.inclusion y).op.obj V) then eqToHom ⋯
      else
        (⋯ ▸ terminalIsTerminal).from ((fun U => if p₀ ∈ unop U then A else ⊤_ C) ((OpenNhds.inclusion y).op.obj U))) ≫
      (fun U => eqToHom ⋯) V =
    (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc
state_after: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ eqToHom ⋯ ≫ (fun U => eqToHom ⋯) V = (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc

case hc
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ p₀ ∈ unop ((OpenNhds.inclusion y).op.obj V)
tactic: rw [dif_pos]
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ eqToHom ⋯ ≫ (fun U => eqToHom ⋯) V = (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc

case hc
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ p₀ ∈ unop ((OpenNhds.inclusion y).op.obj V)
state_after: case hc
X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ p₀ ∈ unop ((OpenNhds.inclusion y).op.obj V)

X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{u, v} C
A : C
inst✝ : HasTerminal C
y : ↑X
h : p₀ ⤳ y
U V : (OpenNhds y)ᵒᵖ
inc : U ⟶ V
⊢ eqToHom ⋯ ≫ (fun U => eqToHom ⋯) V = (fun U => eqToHom ⋯) U ≫ ((Functor.const (OpenNhds y)ᵒᵖ).obj A).map inc
tactic: swap
Theorem: Finsupp.support_extendDomain_subset
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
⊢ ↑f.extendDomain.support ⊆ {x | P x}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : α
⊢ x ∈ ↑f.extendDomain.support → x ∈ {x | P x}
tactic: intro x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : α
⊢ x ∈ ↑f.extendDomain.support → x ∈ {x | P x}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : α
⊢ (∃ a ∈ f.support, ↑a = x) → x ∈ {x | P x}
tactic: rw [extendDomain_support, mem_coe, mem_map, Embedding.coe_subtype]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : α
⊢ (∃ a ∈ f.support, ↑a = x) → x ∈ {x | P x}
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : Subtype P
⊢ ↑x ∈ {x | P x}
tactic: rintro ⟨x, -, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M✝ : Type u_5
M' : Type u_6
N : Type u_7
P✝ : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
M : Type u_13
inst✝¹ : Zero M
P : α → Prop
inst✝ : DecidablePred P
f : Subtype P →₀ M
x : Subtype P
⊢ ↑x ∈ {x | P x}
state_after: no goals
tactic: exact x.prop
Theorem: Cardinal.lift_iSup_le_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
hf : BddAbove (range f)
t : Cardinal.{max u w}
⊢ lift.{u, w} (iSup f) ≤ t ↔ ∀ (i : ι), lift.{u, w} (f i) ≤ t
state_after: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
hf : BddAbove (range f)
t : Cardinal.{max u w}
⊢ ⨆ i, lift.{u, w} (f i) ≤ t ↔ ∀ (i : ι), lift.{u, w} (f i) ≤ t
tactic: rw [lift_iSup hf]
state_before: α β : Type u
ι : Type v
f : ι → Cardinal.{w}
hf : BddAbove (range f)
t : Cardinal.{max u w}
⊢ ⨆ i, lift.{u, w} (f i) ≤ t ↔ ∀ (i : ι), lift.{u, w} (f i) ≤ t
state_after: no goals
tactic: exact ciSup_le_iff' (bddAbove_range_comp.{_,_,u} hf _)
Theorem: RatFunc.toFractionRing_smul
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝¹ : CommRing K
R : Type u_1
inst✝ : SMul R (FractionRing K[X])
c : R
p : RatFunc K
⊢ (c • p).toFractionRing = c • p.toFractionRing
state_after: case ofFractionRing
K : Type u
inst✝¹ : CommRing K
R : Type u_1
inst✝ : SMul R (FractionRing K[X])
c : R
toFractionRing✝ : FractionRing K[X]
⊢ (c • { toFractionRing := toFractionRing✝ }).toFractionRing = c • { toFractionRing := toFractionRing✝ }.toFractionRing
tactic: cases p
state_before: case ofFractionRing
K : Type u
inst✝¹ : CommRing K
R : Type u_1
inst✝ : SMul R (FractionRing K[X])
c : R
toFractionRing✝ : FractionRing K[X]
⊢ (c • { toFractionRing := toFractionRing✝ }).toFractionRing = c • { toFractionRing := toFractionRing✝ }.toFractionRing
state_after: no goals
tactic: rw [← ofFractionRing_smul]
Theorem: EuclideanGeometry.eq_reflection_of_eq_subspace
File: Mathlib/Geometry/Euclidean/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s s' : AffineSubspace ℝ P
inst✝³ : Nonempty ↥s
inst✝² : Nonempty ↥s'
inst✝¹ : HasOrthogonalProjection s.direction
inst✝ : HasOrthogonalProjection s'.direction
h : s = s'
p : P
⊢ (reflection s) p = (reflection s') p
state_after: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝³ : Nonempty ↥s
inst✝² : HasOrthogonalProjection s.direction
p : P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ (reflection s) p = (reflection s) p
tactic: subst h
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝³ : Nonempty ↥s
inst✝² : HasOrthogonalProjection s.direction
p : P
inst✝¹ : Nonempty ↥s
inst✝ : HasOrthogonalProjection s.direction
⊢ (reflection s) p = (reflection s) p
state_after: no goals
tactic: rfl
Theorem: eq_one_div_of_mul_eq_one_left
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
h : b * a = 1
⊢ b = 1 / a
state_after: no goals
tactic: rw [eq_inv_of_mul_eq_one_left h, one_div]
Theorem: NonAssocSemiring.toNonUnitalNonAssocSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalNonAssocSemiring R)
state_after: R : Type u
a₁✝ a₂✝ : NonAssocSemiring R
a✝ : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
⊢ a₁✝ = a₂✝
tactic: intro _ _ _
state_before: R : Type u
a₁✝ a₂✝ : NonAssocSemiring R
a✝ : toNonUnitalNonAssocSemiring = toNonUnitalNonAssocSemiring
⊢ a₁✝ = a₂✝
state_after: no goals
tactic: ext <;> congr
Theorem: NormedAddGroupHom.ker.lift_apply_coe
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : g.comp f = 0
v : V₁
⊢ f v ∈ g.ker
state_after: no goals
tactic: rw [g.mem_ker, ← comp_apply g f, h, zero_apply]
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : g.comp f = 0
v w : V₁
⊢ (fun v => ⟨f v, ⋯⟩) (v + w) = (fun v => ⟨f v, ⋯⟩) v + (fun v => ⟨f v, ⋯⟩) w
state_after: no goals
tactic: simp only [map_add, AddSubmonoid.mk_add_mk]
Theorem: Real.pi_lt_31416
File: Mathlib/Data/Real/Pi/Bounds.lean

Proof steps:
state_before: ⊢ π < 3.1416
state_after: no goals
tactic: pi_upper_bound
        [4756 / 3363, 101211 / 54775, 505534 / 257719, 83289 / 41846, 411278 / 205887,
          438142 / 219137, 451504 / 225769, 265603 / 132804, 849938 / 424971]
Theorem: monovaryOn_inv_right₀
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : LinearOrderedSemifield β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
hg : ∀ i ∈ s, 0 < g i
i : ι
hi : i ∈ s
j : ι
hj : j ∈ s
⊢ g⁻¹ j < g⁻¹ i → f j ≤ f i ↔ g i < g j → f j ≤ f i
state_after: no goals
tactic: erw [inv_lt_inv (hg _ hj) (hg _ hi)]