ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsUpperSet.sdiff_of_isLowerSet
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
hs : IsUpperSet s
ht : IsLowerSet t
⊢ ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t
state_after: no goals
tactic: aesop
Theorem: ProbabilityTheory.setLIntegral_condKernel_univ_right
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a = ∫⁻ (x : β × Ω) in s ×ˢ Set.univ, f x ∂κ a
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a
tactic: rw [← setLIntegral_condKernel hf a hs MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
hf : Measurable f
a : α
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a
state_after: no goals
tactic: simp_rw [Measure.restrict_univ]
Theorem: CauSeq.Completion.inv_zero
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
⊢ (if h : (const abv 0).LimZero then 0 else (const abv 0).inv h) = const abv 0
state_after: no goals
tactic: rw [dif_pos] <;> [rfl; exact zero_limZero]
Theorem: Nat.gcd_add_self_right
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ m.gcd (n + m) = m.gcd (n + 1 * m)
state_after: no goals
tactic: rw [one_mul]
Theorem: List.get?_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m n : Nat
h : m < n
⊢ (range n).get? m = some m
state_after: no goals
tactic: simp [getElem?_range, h]
Theorem: List.Ico.not_mem_top
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m : ℕ
⊢ m ∉ Ico n m
state_after: no goals
tactic: simp
Theorem: Sum.Lex.Ioo_inr_inr
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inrₗ b₁) (inrₗ b₂) = map (Embedding.inr.trans toLex.toEmbedding) (Ioo b₁ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ioo b₁ b₂))
tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ioo b₁ b₂))
state_after: no goals
tactic: rfl
Theorem: List.monotone_filter_left
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l l' : List α
h : l ⊆ l'
⊢ filter p l ⊆ filter p l'
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l l' : List α
h : l ⊆ l'
x : α
hx : x ∈ filter p l
⊢ x ∈ filter p l'
tactic: intro x hx
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l l' : List α
h : l ⊆ l'
x : α
hx : x ∈ filter p l
⊢ x ∈ filter p l'
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l l' : List α
h : l ⊆ l'
x : α
hx : x ∈ l ∧ p x = true
⊢ x ∈ l' ∧ p x = true
tactic: rw [mem_filter] at hx ⊢
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ p : α → Bool
l l' : List α
h : l ⊆ l'
x : α
hx : x ∈ l ∧ p x = true
⊢ x ∈ l' ∧ p x = true
state_after: no goals
tactic: exact ⟨h hx.left, hx.right⟩
Theorem: CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g f₁ f₂ : CircleDeg1Lift
h₁ : IsUnit f₁
h₂ : IsUnit f₂
h : τ f₁ = τ f₂
⊢ ∃ F, Semiconj ⇑F ⇑f₁ ⇑f₂
state_after: case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ⇑F ⇑↑f₁ ⇑↑f₂
tactic: rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
state_before: case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ⇑F ⇑↑f₁ ⇑↑f₂
state_after: no goals
tactic: exact units_semiconj_of_translationNumber_eq h
Theorem: List.getElem?_modifyNth_ne
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → α
m n : Nat
l : List α
h : m ≠ n
⊢ (modifyNth f m l)[n]? = l[n]?
state_after: no goals
tactic: simp only [getElem?_modifyNth, if_neg h, id_map']
Theorem: AddSubgroup.mem_closure_pair
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ z ∈ closure {x, y} ↔ ∃ m n, x ^ m * y ^ n = z
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ (∃ y_1 ∈ closure {x}, ∃ z_1 ∈ closure {y}, y_1 * z_1 = z) ↔ ∃ m n, x ^ m * y ^ n = z
tactic: rw [← Set.singleton_union, Subgroup.closure_union, mem_sup]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
N : Type u_5
inst✝¹ : Group N
C : Type u_6
inst✝ : CommGroup C
s t : Subgroup C
x✝ x y z : C
⊢ (∃ y_1 ∈ closure {x}, ∃ z_1 ∈ closure {y}, y_1 * z_1 = z) ↔ ∃ m n, x ^ m * y ^ n = z
state_after: no goals
tactic: simp_rw [mem_closure_singleton, exists_exists_eq_and]
Theorem: Metric.eventually_not_mem_cthickening_of_infEdist_pos
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E
state_after: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E
tactic: obtain ⟨ε, ⟨ε_pos, ε_lt⟩⟩ := exists_real_pos_lt_infEdist_of_not_mem_closure h
state_before: case intro.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
⊢ ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E
state_after: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
δ : ℝ
hδ : δ < ε
⊢ x ∉ cthickening δ E
tactic: filter_upwards [eventually_lt_nhds ε_pos] with δ hδ
state_before: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
δ : ℝ
hδ : δ < ε
⊢ x ∉ cthickening δ E
state_after: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
δ : ℝ
hδ : δ < ε
⊢ ENNReal.ofReal δ < infEdist x E
tactic: simp only [cthickening, mem_setOf_eq, not_le]
state_before: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε✝ : ℝ
s t : Set α
x✝ : α
E : Set α
x : α
h : x ∉ closure E
ε : ℝ
ε_pos : 0 < ε
ε_lt : ENNReal.ofReal ε < infEdist x E
δ : ℝ
hδ : δ < ε
⊢ ENNReal.ofReal δ < infEdist x E
state_after: no goals
tactic: exact ((ofReal_lt_ofReal_iff ε_pos).mpr hδ).trans ε_lt
Theorem: CategoryTheory.ChosenFiniteProducts.associator_hom_snd_fst
File: Mathlib/CategoryTheory/ChosenFiniteProducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ (α_ X Y Z).hom ≫ snd X (Y ⊗ Z) ≫ fst Y Z = fst (X ⊗ Y) Z ≫ snd X Y
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.fst (product (product X Y).cone.pt Z).cone ≫ Limits.BinaryFan.snd (product X Y).cone =
    fst (X ⊗ Y) Z ≫ snd X Y
tactic: erw [lift_snd_assoc, lift_fst]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ChosenFiniteProducts C
X Y Z : C
⊢ Limits.BinaryFan.fst (product (product X Y).cone.pt Z).cone ≫ Limits.BinaryFan.snd (product X Y).cone =
    fst (X ⊗ Y) Z ≫ snd X Y
state_after: no goals
tactic: rfl
Theorem: Matroid.sum'_basis_iff
File: Mathlib/Data/Matroid/Sum.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
M : ι → Matroid α
I X : Set (ι × α)
⊢ (Matroid.sum' M).Basis I X ↔ ∀ (i : ι), (M i).Basis (Prod.mk i ⁻¹' I) (Prod.mk i ⁻¹' X)
state_after: α : Type u_1
ι : Type u_2
M : ι → Matroid α
I X : Set (ι × α)
⊢ (∀ (i : ι), (M i).Basis (Sigma.mk i ⁻¹' ((fun a => ⟨a.1, a.2⟩) '' I)) (Sigma.mk i ⁻¹' ((fun a => ⟨a.1, a.2⟩) '' X))) ↔
    ∀ (i : ι), (M i).Basis (Prod.mk i ⁻¹' I) (Prod.mk i ⁻¹' X)
tactic: simp [Matroid.sum']
state_before: α : Type u_1
ι : Type u_2
M : ι → Matroid α
I X : Set (ι × α)
⊢ (∀ (i : ι), (M i).Basis (Sigma.mk i ⁻¹' ((fun a => ⟨a.1, a.2⟩) '' I)) (Sigma.mk i ⁻¹' ((fun a => ⟨a.1, a.2⟩) '' X))) ↔
    ∀ (i : ι), (M i).Basis (Prod.mk i ⁻¹' I) (Prod.mk i ⁻¹' X)
state_after: no goals
tactic: convert Iff.rfl <;>
  exact ext <| by simp
Theorem: LeftOrdContinuous.mono
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
hf : LeftOrdContinuous f
a₁ a₂ : α
h : a₁ ≤ a₂
⊢ a₂ ∈ upperBounds {a₁, a₂}
state_after: no goals
tactic: simp [*]
Theorem: MeasureTheory.FiniteMeasure.eq_of_forall_toMeasure_apply_eq
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ μ = ν
state_after: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ ↑μ = ↑ν
tactic: apply Subtype.ext
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ ↑μ = ↑ν
state_after: case a.h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑μ s = ↑ν s
tactic: ext1 s s_mble
state_before: case a.h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑μ s = ↑ν s
state_after: no goals
tactic: exact h s s_mble
Theorem: Num.pred_succ
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ (pos p).succ'.pred'.toZNumNeg = ZNum.neg p
state_after: α : Type u_1
p : PosNum
⊢ (pos p).toZNumNeg = ZNum.neg p
tactic: rw [PosNum.pred'_succ']
state_before: α : Type u_1
p : PosNum
⊢ (pos p).toZNumNeg = ZNum.neg p
state_after: no goals
tactic: rfl
state_before: α : Type u_1
p : PosNum
⊢ (ZNum.pos p).pred.succ = ZNum.pos p
state_after: no goals
tactic: rw [ZNum.pred, ← toZNum_succ, Num.succ, PosNum.succ'_pred', toZNum]
Theorem: FractionalIdeal.coeIdealHom_apply
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
⊢ ↑1 = 1
state_after: no goals
tactic: rw [Ideal.one_eq_top, coeIdeal_top]
Theorem: finsum_mem_eq_finite_toFinset_sum
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 : α → M
s : Set α
hs : s.Finite
⊢ s ∩ mulSupport f = ↑hs.toFinset ∩ mulSupport f
state_after: no goals
tactic: rw [hs.coe_toFinset]
Theorem: IsExposed.inter_right
File: Mathlib/Analysis/Convex/Exposed.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (A ∩ B) C
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (B ∩ A) C
tactic: rw [inter_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (B ∩ A) C
state_after: no goals
tactic: exact hC.inter_left hCA
Theorem: Function.Periodic.add_const
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (x + a)) (x + c) = (fun x => f (x + a)) x
state_after: no goals
tactic: simpa only [add_right_comm] using h (x + a)
Theorem: WeierstrassCurve.Jacobian.equation_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ W'.Equation P ↔
    P y ^ 2 + W'.a₁ * P x * P y * P z + W'.a₃ * P y * P z ^ 3 -
        (P x ^ 3 + W'.a₂ * P x ^ 2 * P z ^ 2 + W'.a₄ * P x * P z ^ 4 + W'.a₆ * P z ^ 6) =
      0
state_after: no goals
tactic: rw [Equation, eval_polynomial]
Theorem: LieSubmodule.baseChange_bot
File: Mathlib/Algebra/Lie/BaseChange.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
N : LieSubmodule R L M
⊢ baseChange A ⊥ = ⊥
state_after: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
N : LieSubmodule R L M
⊢ { toSubmodule := ⊥, lie_mem := ⋯ } = ⊥
tactic: simp only [baseChange, bot_coeSubmodule, Submodule.baseChange_bot,
    Submodule.bot_toAddSubmonoid]
state_before: R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
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
inst✝¹ : CommRing A
inst✝ : Algebra R A
N : LieSubmodule R L M
⊢ { toSubmodule := ⊥, lie_mem := ⋯ } = ⊥
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.Spec.basicOpen_hom_ext
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: X : RingedSpace
R : CommRingCat
α β : X ⟶ sheafedSpaceObj R
w : α.base = β.base
r : ↑R
U : TopologicalSpace.Opens (PrimeSpectrum ↑R) := PrimeSpectrum.basicOpen r
⊢ (TopologicalSpace.Opens.map α.base).op.obj (op U) = (TopologicalSpace.Opens.map β.base).op.obj (op U)
state_after: no goals
tactic: rw [w]
state_before: X : RingedSpace
R : CommRingCat
α β : X ⟶ sheafedSpaceObj R
w : α.base = β.base
h :
  ∀ (r : ↑R),
    let U := PrimeSpectrum.basicOpen r;
    (toOpen (↑R) U ≫ α.c.app (op U)) ≫ X.presheaf.map (eqToHom ⋯) = toOpen (↑R) U ≫ β.c.app (op U)
⊢ α = β
state_after: case w
X : RingedSpace
R : CommRingCat
α β : X ⟶ sheafedSpaceObj R
w : α.base = β.base
h :
  ∀ (r : ↑R),
    let U := PrimeSpectrum.basicOpen r;
    (toOpen (↑R) U ≫ α.c.app (op U)) ≫ X.presheaf.map (eqToHom ⋯) = toOpen (↑R) U ≫ β.c.app (op U)
⊢ α.base = β.base

case h
X : RingedSpace
R : CommRingCat
α β : X ⟶ sheafedSpaceObj R
w : α.base = β.base
h :
  ∀ (r : ↑R),
    let U := PrimeSpectrum.basicOpen r;
    (toOpen (↑R) U ≫ α.c.app (op U)) ≫ X.presheaf.map (eqToHom ⋯) = toOpen (↑R) U ≫ β.c.app (op U)
⊢ α.c ≫ whiskerRight (eqToHom ⋯) X.presheaf = β.c
tactic: ext : 1
Theorem: CategoryTheory.CosimplicialObject.Augmented.whiskering_map_app_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ ((const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)).app n
tactic: ext n
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ ((const D).map (η.app (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)).app n
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ η.app A.left ≫ 𝟙 (Y✝.obj A.left) ≫ Y✝.map (A.hom.app n) =
    (𝟙 (X✝.obj A.left) ≫ X✝.map (A.hom.app n)) ≫ η.app (A.right.obj n)
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ η.app A.left ≫ 𝟙 (Y✝.obj A.left) ≫ Y✝.map (A.hom.app n) =
    (𝟙 (X✝.obj A.left) ≫ X✝.map (A.hom.app n)) ≫ η.app (A.right.obj n)
state_after: no goals
tactic: rw [Category.id_comp, Category.id_comp, η.naturality]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
⊢ (whiskeringObj C D X✝).map f ≫
      (fun A => { left := η.app (point.obj A), right := whiskerLeft (drop.obj A) η, w := ⋯ }) x✝ =
    (fun A => { left := η.app (point.obj A), right := whiskerLeft (drop.obj A) η, w := ⋯ }) x✝¹ ≫
      (whiskeringObj C D Y✝).map f
state_after: no goals
tactic: ext <;> dsimp <;> simp
Theorem: one_le_inv
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h₁ : 0 < a
h₂ : a ≤ 1
⊢ 1 ≤ a⁻¹
state_after: no goals
tactic: rwa [le_inv (@zero_lt_one α _ _ _ _ _) h₁, inv_one]
Theorem: dense_of_exists_between
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
⊢ Dense s
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
⊢ (U ∩ s).Nonempty
tactic: refine dense_iff_inter_open.2 fun U U_open U_nonempty => ?_
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
⊢ (U ∩ s).Nonempty
state_after: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
a b : α
hab : a < b
H : Ioo a b ⊆ U
⊢ (U ∩ s).Nonempty
tactic: obtain ⟨a, b, hab, H⟩ : ∃ a b : α, a < b ∧ Ioo a b ⊆ U := U_open.exists_Ioo_subset U_nonempty
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
a b : α
hab : a < b
H : Ioo a b ⊆ U
⊢ (U ∩ s).Nonempty
state_after: case intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
a b : α
hab : a < b
H : Ioo a b ⊆ U
x : α
xs : x ∈ s
hx : a < x ∧ x < b
⊢ (U ∩ s).Nonempty
tactic: obtain ⟨x, xs, hx⟩ : ∃ x ∈ s, a < x ∧ x < b := h hab
state_before: case intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
s : Set α
h : ∀ ⦃a b : α⦄, a < b → ∃ c ∈ s, a < c ∧ c < b
U : Set α
U_open : IsOpen U
U_nonempty : U.Nonempty
a b : α
hab : a < b
H : Ioo a b ⊆ U
x : α
xs : x ∈ s
hx : a < x ∧ x < b
⊢ (U ∩ s).Nonempty
state_after: no goals
tactic: exact ⟨x, ⟨H hx, xs⟩⟩
Theorem: MulAction.zpow_smul_eq_iff_period_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
j : ℤ
g : G
a : α
⊢ g ^ j • a = a ↔ ↑(period g a) ∣ j
state_after: case ofNat
α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
g : G
a : α
n : ℕ
⊢ g ^ Int.ofNat n • a = a ↔ ↑(period g a) ∣ Int.ofNat n

case negSucc
α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
g : G
a : α
n : ℕ
⊢ g ^ Int.negSucc n • a = a ↔ ↑(period g a) ∣ Int.negSucc n
tactic: rcases j with n | n
Theorem: add_sub_left_comm
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✝ : DivisionCommMonoid α
a b c d : α
⊢ a * (b / c) = b * (a / c)
state_after: no goals
tactic: simp
Theorem: disjoint_frontier_iff_isOpen
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
⊢ Disjoint (frontier s) s ↔ IsOpen s
state_after: no goals
tactic: rw [← isClosed_compl_iff, ← frontier_subset_iff_isClosed,
    frontier_compl, subset_compl_iff_disjoint_right]