ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: measurable_updateFinset
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
inst✝ : DecidableEq δ
s : Finset δ
x : (i : δ) → π i
⊢ Measurable (updateFinset x s)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
inst✝ : DecidableEq δ
s : Finset δ
x : (i : δ) → π i
⊢ ∀ (a : δ), Measurable fun x_1 => if hi : a ∈ s then x_1 ⟨a, hi⟩ else x a
tactic: simp (config := { unfoldPartialApp := true }) only [updateFinset, measurable_pi_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
inst✝ : DecidableEq δ
s : Finset δ
x : (i : δ) → π i
⊢ ∀ (a : δ), Measurable fun x_1 => if hi : a ∈ s then x_1 ⟨a, hi⟩ else x a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
inst✝ : DecidableEq δ
s : Finset δ
x : (i : δ) → π i
i : δ
⊢ Measurable fun x_1 => if hi : i ∈ s then x_1 ⟨i, hi⟩ else x i
tactic: intro i
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_6
inst✝³ : MeasurableSpace α
inst✝² : (a : δ) → MeasurableSpace (π a)
inst✝¹ : MeasurableSpace γ
inst✝ : DecidableEq δ
s : Finset δ
x : (i : δ) → π i
i : δ
⊢ Measurable fun x_1 => if hi : i ∈ s then x_1 ⟨i, hi⟩ else x i
state_after: no goals
tactic: by_cases h : i ∈ s <;> simp [h, measurable_pi_apply]
Theorem: Pell.IsFundamental.x_mul_y_le_y_mul_x
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ a.x * a₁.y ≤ a.y * a₁.x
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ 0 ≤ a.y ^ 2 * (1 + d * a₁.y ^ 2) - (1 + d * a.y ^ 2) * a₁.y ^ 2
tactic: rw [← abs_of_pos <| zero_lt_one.trans hax, ← abs_of_pos hay, ← abs_of_pos h.x_pos, ←
    abs_of_pos h.2.1, ← abs_mul, ← abs_mul, ← sq_le_sq, mul_pow, mul_pow, a.prop_x, a₁.prop_x, ←
    sub_nonneg]
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ 0 ≤ a.y ^ 2 * (1 + d * a₁.y ^ 2) - (1 + d * a.y ^ 2) * a₁.y ^ 2
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ 0 ≤ a.y ^ 2 - a₁.y ^ 2
tactic: ring_nf
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ 0 ≤ a.y ^ 2 - a₁.y ^ 2
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ a₁.y ≤ a.y
tactic: rw [sub_nonneg, sq_le_sq, abs_of_pos hay, abs_of_pos h.2.1]
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ a₁.y ≤ a.y
state_after: no goals
tactic: exact h.y_le_y hax hay
Theorem: Ordinal.smul_eq_mul
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ 0 • a = a * ↑0
state_after: no goals
tactic: rw [zero_nsmul, Nat.cast_zero, mul_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
n : ℕ
a : Ordinal.{u_4}
⊢ (n + 1) • a = a * ↑(n + 1)
state_after: no goals
tactic: rw [succ_nsmul, Nat.cast_add, mul_add, Nat.cast_one, mul_one, smul_eq_mul n]
Theorem: Fin.univ_succ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ 0 ∉ map { toFun := succ, inj' := ⋯ } univ
state_after: no goals
tactic: simp [map_eq_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
⊢ univ = Finset.cons 0 (map { toFun := succ, inj' := ⋯ } univ) ⋯
state_after: no goals
tactic: simp [map_eq_image]
Theorem: WeierstrassCurve.Affine.baseChange_polynomialX
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
⊢ (baseChange W B).toAffine.polynomialX = Polynomial.map (mapRingHom ↑f) (baseChange W A).toAffine.polynomialX
state_after: no goals
tactic: rw [← map_polynomialX, map_baseChange]
Theorem: Finset.prod_div_prod_mem_mulSpan
File: Mathlib/Combinatorics/Additive/Dissociation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : CommGroup α
inst✝² : CommGroup β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s t u : Finset α
a✝ : α
d : ℕ
ht : t ⊆ s
hu : u ⊆ s
a : α
⊢ ((↑t).indicator 1 - (↑u).indicator 1) a = -1 ∨
    ((↑t).indicator 1 - (↑u).indicator 1) a = 0 ∨ ((↑t).indicator 1 - (↑u).indicator 1) a = 1
state_after: no goals
tactic: by_cases a ∈ t <;> by_cases a ∈ u <;> simp [*]
state_before: α : Type u_1
β : Type u_2
inst✝³ : CommGroup α
inst✝² : CommGroup β
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s t u : Finset α
a : α
d : ℕ
ht : t ⊆ s
hu : u ⊆ s
⊢ ∏ a ∈ s, a ^ ((↑t).indicator 1 - (↑u).indicator 1) a = (∏ a ∈ t, a) / ∏ a ∈ u, a
state_after: no goals
tactic: simp [prod_div_distrib, zpow_sub,
      ← div_eq_mul_inv, Set.indicator, pow_ite, inter_eq_right.2, *]
Theorem: DenseInducing.closure_image_mem_nhds
File: Mathlib/Topology/DenseEmbedding.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : s ∈ 𝓝 a
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : ∃ i_1, (i a ∈ i_1 ∧ IsOpen i_1) ∧ i ⁻¹' i_1 ⊆ s
⊢ closure (i '' s) ∈ 𝓝 (i a)
tactic: rw [di.nhds_eq_comap a, ((nhds_basis_opens _).comap _).mem_iff] at hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : ∃ i_1, (i a ∈ i_1 ∧ IsOpen i_1) ∧ i ⁻¹' i_1 ⊆ s
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ closure (i '' s) ∈ 𝓝 (i a)
tactic: rcases hs with ⟨U, ⟨haU, hUo⟩, sub : i ⁻¹' U ⊆ s⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ U ⊆ closure (i '' s)
tactic: refine mem_of_superset (hUo.mem_nhds haU) ?_
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ U ⊆ closure (i '' s)
state_after: no goals
tactic: calc
    U ⊆ closure (i '' (i ⁻¹' U)) := di.dense.subset_closure_image_preimage_of_isOpen hUo
    _ ⊆ closure (i '' s) := closure_mono (image_subset i sub)
Theorem: closedBall_div_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall x δ / {y} = closedBall (x / y) δ
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: inf_sup_assoc_of_le
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x y z : α
h : z ≤ x
⊢ x ⊓ y ⊔ z = x ⊓ (y ⊔ z)
state_after: no goals
tactic: rw [inf_comm, sup_comm, ← sup_inf_assoc_of_le y h, inf_comm, sup_comm]
Theorem: HasSum.hasSum_compl_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (f ∘ Subtype.val) a₁
⊢ HasProd (f ∘ Subtype.val) a₂ ↔ HasProd f (a₁ * a₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (f ∘ Subtype.val) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (f ∘ Subtype.val) a₂
tactic: refine ⟨fun h ↦ hf.mul_compl h, fun h ↦ ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (f ∘ Subtype.val) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (f ∘ Subtype.val) a₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (s.mulIndicator f) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (sᶜ.mulIndicator f) a₂
tactic: rw [hasProd_subtype_iff_mulIndicator] at hf ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (s.mulIndicator f) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (sᶜ.mulIndicator f) a₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (s.mulIndicator f) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (f * (s.mulIndicator f)⁻¹) a₂
tactic: rw [Set.mulIndicator_compl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
s : Set β
hf : HasProd (s.mulIndicator f) a₁
h : HasProd f (a₁ * a₂)
⊢ HasProd (f * (s.mulIndicator f)⁻¹) a₂
state_after: no goals
tactic: simpa only [div_eq_mul_inv, mul_inv_cancel_comm] using h.div hf
Theorem: TopCat.GlueData.preimage_image_eq_image'
File: Mathlib/Topology/Gluing.lean

Proof steps:
state_before: D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.ι j) ⁻¹' (⇑(D.ι i) '' U) = ⇑(D.t i j ≫ D.f j i) '' (⇑(D.f i j) ⁻¹' U)
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.t i j ≫ D.f j i) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f j i) '' (⇑(D.t j i ≫ D.f i j) ⁻¹' U)
tactic: convert D.preimage_image_eq_image i j U using 1
state_before: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.t i j ≫ D.f j i) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f j i) '' (⇑(D.t j i ≫ D.f i j) ⁻¹' U)
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.f j i) ∘ ⇑(D.t i j) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
tactic: rw [coe_comp, coe_comp]
state_before: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.f j i) ∘ ⇑(D.t i j) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (fun x => (forget TopCat).map (D.f j i) ((forget TopCat).map (D.t i j) x)) '' (⇑(D.f i j) ⁻¹' U) =
    ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
tactic: show (fun x => ((forget TopCat).map _ ((forget TopCat).map _ x))) '' _ = _
state_before: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (fun x => (forget TopCat).map (D.f j i) ((forget TopCat).map (D.t i j) x)) '' (⇑(D.f i j) ⁻¹' U) =
    ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (forget TopCat).map (D.f j i) '' ((forget TopCat).map (D.t i j) '' (⇑(D.f i j) ⁻¹' U)) =
    ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
tactic: rw [← Set.image_image]
state_before: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (forget TopCat).map (D.f j i) '' ((forget TopCat).map (D.t i j) '' (⇑(D.f i j) ⁻¹' U)) =
    ⇑(D.f j i) '' (⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U)
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (forget TopCat).map (D.t i j) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U
tactic: refine congr_arg ?_ ?_
state_before: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ (forget TopCat).map (D.t i j) '' (⇑(D.f i j) ⁻¹' U) = ⇑(D.f i j) ∘ ⇑(D.t j i) ⁻¹' U
state_after: case h.e'_3
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ ⇑(D.f i j) ⁻¹' U = (fun x => (⇑(D.f i j) ∘ ⇑(D.t j i)) ((forget TopCat).map (D.t i j) x)) ⁻¹' U

case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ Function.Bijective ((forget TopCat).map (D.t i j))
tactic: rw [← Set.eq_preimage_iff_image_eq, Set.preimage_preimage]
state_before: case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ Function.Bijective ((forget TopCat).map (D.t i j))
state_after: case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ IsIso ((forget TopCat).map (D.t i j))
tactic: rw [← isIso_iff_bijective]
state_before: case h.e'_3.hf
D : GlueData
i j : D.J
U : Set ↑(D.U i)
⊢ IsIso ((forget TopCat).map (D.t i j))
state_after: no goals
tactic: apply (forget TopCat).map_isIso
Theorem: List.range_sublist
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: m n : Nat
⊢ range m <+ range n ↔ m ≤ n
state_after: no goals
tactic: simp only [range_eq_range', range'_sublist_right]
Theorem: Set.nonempty_biUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s✝ : ι → Set α
t : Set α
s : α → Set β
⊢ (⋃ i ∈ t, s i).Nonempty ↔ ∃ i ∈ t, (s i).Nonempty
state_after: no goals
tactic: simp
Theorem: UniformConcaveOn.sub
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConcaveOn s φ f
hg : UniformConvexOn s ψ g
⊢ UniformConcaveOn s (φ + ψ) (f - g)
state_after: no goals
tactic: simpa using hf.add hg.neg
Theorem: Set.mem_ite_empty_right
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : Set α
x : α
⊢ (∃ (_ : p), x ∈ t) ↔ p ∧ x ∈ t
state_after: no goals
tactic: simp
Theorem: variationOnFromTo.eq_zero_iff
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ variationOnFromTo f s a b = 0 ↔ ∀ ⦃x : α⦄, x ∈ s ∩ uIcc a b → ∀ ⦃y : α⦄, y ∈ s ∩ uIcc a b → edist (f x) (f y) = 0
state_after: case inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
ab : a ≤ b
⊢ variationOnFromTo f s a b = 0 ↔ ∀ ⦃x : α⦄, x ∈ s ∩ uIcc a b → ∀ ⦃y : α⦄, y ∈ s ∩ uIcc a b → edist (f x) (f y) = 0

case inr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f✝ : α → E
s✝ : Set α
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
ba : b ≤ a
⊢ variationOnFromTo f s a b = 0 ↔ ∀ ⦃x : α⦄, x ∈ s ∩ uIcc a b → ∀ ⦃y : α⦄, y ∈ s ∩ uIcc a b → edist (f x) (f y) = 0
tactic: rcases le_total a b with (ab | ba)
Theorem: Fin.sub_one_lt_iff
File: Mathlib/Algebra/Group/Fin/Basic.lean

Proof steps:
state_before: m n : ℕ
k : Fin (n + 1)
⊢ ¬k - 1 < k ↔ ¬0 < k
state_after: no goals
tactic: simp only [lt_def, not_lt, val_fin_le, le_sub_one_iff, le_zero_iff]
Theorem: MultilinearMap.map_add_eq_map_add_linearDeriv_add
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin n.succ → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : Semiring R
inst✝⁵ : (i : ι) → AddCommGroup (M₁ i)
inst✝⁴ : AddCommGroup M₂
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
f : MultilinearMap R M₁ M₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
x h : (i : ι) → M₁ i
⊢ ∑ x_1 ∈ filter (fun x => 2 ≤ x.card) Finset.univ.powerset, f (x_1.piecewise h x) +
      ∑ x_1 ∈ filter (fun x => ¬2 ≤ x.card) Finset.univ.powerset, f (x_1.piecewise h x) =
    f x + (f.linearDeriv x) h + ∑ s ∈ filter (fun x => 2 ≤ x.card) Finset.univ.powerset, f (s.piecewise h x)
state_after: no goals
tactic: simp_rw [not_le, Nat.lt_succ, le_iff_lt_or_eq (b := 1), Nat.lt_one_iff, filter_or,
    ← powersetCard_eq_filter, sum_union (univ.pairwise_disjoint_powersetCard zero_ne_one),
    powersetCard_zero, powersetCard_one, sum_singleton, Finset.piecewise_empty, sum_map,
    Function.Embedding.coeFn_mk, Finset.piecewise_singleton, linearDeriv_apply, add_comm]
Theorem: AlgebraicGeometry.isLocallyNoetherian_iff_of_affine_openCover
File: Mathlib/AlgebraicGeometry/Noetherian.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ IsLocallyNoetherian X ↔ ∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)
state_after: case mp
X : Scheme
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ IsLocallyNoetherian X → ∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)

case mpr
X : Scheme
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
⊢ (∀ (i : 𝒰.J), IsNoetherianRing ↑Γ(𝒰.obj i, ⊤)) → IsLocallyNoetherian X
tactic: constructor
Theorem: Finset.piecewise_singleton
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f g : (i : ι) → π i
inst✝¹ : (j : ι) → Decidable (j ∈ s)
inst✝ : DecidableEq ι
i : ι
⊢ {i}.piecewise f g = update g i (f i)
state_after: no goals
tactic: rw [← insert_emptyc_eq, piecewise_insert, piecewise_empty]
Theorem: Order.Coframe.MinimalAxioms.sup_iInf₂_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
minAx : MinimalAxioms α
s : Set α
a✝ b : α
f : (i : ι) → κ i → α
a : α
⊢ a ⊔ ⨅ i, ⨅ j, f i j = ⨅ i, ⨅ j, a ⊔ f i j
state_after: no goals
tactic: simp only [sup_iInf_eq]
Theorem: Finset.antidiagonal_zero
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
⊢ antidiagonal 0 = {(0, 0)}
state_after: case a.mk
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
x y : A
⊢ (x, y) ∈ antidiagonal 0 ↔ (x, y) ∈ {(0, 0)}
tactic: ext ⟨x, y⟩
state_before: case a.mk
A : Type u_1
inst✝¹ : CanonicallyOrderedAddCommMonoid A
inst✝ : HasAntidiagonal A
x y : A
⊢ (x, y) ∈ antidiagonal 0 ↔ (x, y) ∈ {(0, 0)}
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.measurable_compProdFun_of_finite
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => κ.compProdFun η a s
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂κ a
tactic: simp only [compProdFun]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂κ a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
h_meas : Measurable (Function.uncurry fun a b => (η (a, b)) {c | (b, c) ∈ s})
⊢ Measurable fun a => ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂κ a
tactic: have h_meas : Measurable (Function.uncurry fun a b => η (a, b) {c : γ | (b, c) ∈ s}) := by
    have :
      (Function.uncurry fun a b => η (a, b) {c : γ | (b, c) ∈ s}) = fun p =>
        η p {c : γ | (p.2, c) ∈ s} := by
      ext1 p
      rw [Function.uncurry_apply_pair]
    rw [this]
    exact measurable_kernel_prod_mk_left (measurable_fst.snd.prod_mk measurable_snd hs)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
h_meas : Measurable (Function.uncurry fun a b => (η (a, b)) {c | (b, c) ∈ s})
⊢ Measurable fun a => ∫⁻ (b : β), (η (a, b)) {c | (b, c) ∈ s} ∂κ a
state_after: no goals
tactic: exact h_meas.lintegral_kernel_prod_right
Theorem: exists_clusterPt_of_compactSpace
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
s t : Set X
inst✝¹ : CompactSpace X
f : Filter X
inst✝ : f.NeBot
⊢ ∃ x, ClusterPt x f
state_after: no goals
tactic: simpa using isCompact_univ (show f ≤ 𝓟 univ by simp)
Theorem: LieDerivation.apply_lie_eq_add
File: Mathlib/Algebra/Lie/Derivation/Basic.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
D✝ D1 D2 : LieDerivation R L M
a✝ b✝ : L
D : LieDerivation R L L
a b : L
⊢ D ⁅a, b⁆ = ⁅a, D b⁆ + ⁅D a, b⁆
state_after: no goals
tactic: rw [LieDerivation.apply_lie_eq_sub, sub_eq_add_neg, lie_skew]
Theorem: irrational_int_mul_iff
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑m * x) ↔ m ≠ 0 ∧ Irrational x
state_after: no goals
tactic: rw [← cast_intCast, irrational_rat_mul_iff, Int.cast_ne_zero]
Theorem: Set.prod_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : (i : ι) → κ i → Set β
⊢ s ×ˢ ⋃ i, ⋃ j, t i j = ⋃ i, ⋃ j, s ×ˢ t i j
state_after: no goals
tactic: simp_rw [prod_iUnion]
Theorem: Int.ceil_le_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a⌉ ≤ ⌊a⌋ + 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ a ≤ ↑⌊a⌋ + 1
tactic: rw [ceil_le, Int.cast_add, Int.cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ a ≤ ↑⌊a⌋ + 1
state_after: no goals
tactic: exact (lt_floor_add_one a).le