ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.support_inf
File: Mathlib/Data/DFinsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddCommMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
⊢ (f ⊓ g).support = f.support ∩ g.support
state_after: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddCommMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ a✝ ∈ (f ⊓ g).support ↔ a✝ ∈ f.support ∩ g.support
tactic: ext
state_before: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddCommMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ a✝ ∈ (f ⊓ g).support ↔ a✝ ∈ f.support ∩ g.support
state_after: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddCommMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ ¬f a✝ ⊓ g a✝ = 0 ↔ ¬f a✝ = 0 ∧ ¬g a✝ = 0
tactic: simp only [inf_apply, mem_support_iff, Ne, Finset.mem_inter]
state_before: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddCommMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ ¬f a✝ ⊓ g a✝ = 0 ↔ ¬f a✝ = 0 ∧ ¬g a✝ = 0
state_after: no goals
tactic: simp only [inf_eq_min, ← nonpos_iff_eq_zero, min_le_iff, not_or]
Theorem: PMF.toPMF_dirac
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
inst✝¹ : MeasurableSpace α
inst✝ : Countable α
h : MeasurableSingletonClass α
⊢ (Measure.dirac a).toPMF = pure a
state_after: no goals
tactic: rw [toPMF_eq_iff_toMeasure_eq, toMeasure_pure]
Theorem: Polynomial.coeff_zero_reverse
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ f.reverse.coeff 0 = f.leadingCoeff
state_after: no goals
tactic: rw [coeff_reverse, revAt_le (zero_le f.natDegree), tsub_zero, leadingCoeff]
Theorem: CategoryTheory.Adjunction.homEquiv_naturality_left_square_iff
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y'
h : F.obj X' ⟶ Y
k : Y ⟶ Y'
w : f ≫ (adj.homEquiv X Y') g = (adj.homEquiv X' Y) h ≫ G.map k
⊢ F.map f ≫ g = h ≫ k
state_after: no goals
tactic: simpa only [Equiv.symm_apply_apply]
      using homEquiv_naturality_right_square adj _ _ _ _ w
Theorem: Finite.card_le_of_surjective
File: Mathlib/Data/Finite/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
⊢ Nat.card β ≤ Nat.card α
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this : Fintype α
⊢ Nat.card β ≤ Nat.card α
tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this : Fintype α
⊢ Nat.card β ≤ Nat.card α
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this✝ : Fintype α
this : Fintype β
⊢ Nat.card β ≤ Nat.card α
tactic: haveI := Fintype.ofSurjective f hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
f : α → β
hf : Function.Surjective f
this✝ : Fintype α
this : Fintype β
⊢ Nat.card β ≤ Nat.card α
state_after: no goals
tactic: simpa only [Nat.card_eq_fintype_card] using Fintype.card_le_of_surjective f hf
Theorem: Fin.le_castPred_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
j : Fin n
i : Fin (n + 1)
hi : i ≠ last n
⊢ j ≤ i.castPred hi ↔ j.castSucc ≤ i
state_after: no goals
tactic: rw [← castSucc_le_castSucc_iff, castSucc_castPred]
Theorem: ProbabilityTheory.gammaCDFReal_eq_lintegral
File: Mathlib/Probability/Distributions/Gamma.lean

Proof steps:
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
x : ℝ
⊢ ↑(gammaCDFReal a r) x = (∫⁻ (x : ℝ) in Iic x, gammaPDF a r x).toReal
state_after: a r : ℝ
ha : 0 < a
hr : 0 < r
x : ℝ
this : IsProbabilityMeasure (gammaMeasure a r)
⊢ ↑(gammaCDFReal a r) x = (∫⁻ (x : ℝ) in Iic x, gammaPDF a r x).toReal
tactic: have : IsProbabilityMeasure (gammaMeasure a r) := isProbabilityMeasureGamma ha hr
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
x : ℝ
this : IsProbabilityMeasure (gammaMeasure a r)
⊢ ↑(gammaCDFReal a r) x = (∫⁻ (x : ℝ) in Iic x, gammaPDF a r x).toReal
state_after: a r : ℝ
ha : 0 < a
hr : 0 < r
x : ℝ
this : IsProbabilityMeasure (gammaMeasure a r)
⊢ ((gammaMeasure a r) (Iic x)).toReal = (∫⁻ (x : ℝ) in Iic x, ENNReal.ofReal (gammaPDFReal a r x)).toReal
tactic: simp only [gammaPDF, gammaCDFReal, cdf_eq_toReal]
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
x : ℝ
this : IsProbabilityMeasure (gammaMeasure a r)
⊢ ((gammaMeasure a r) (Iic x)).toReal = (∫⁻ (x : ℝ) in Iic x, ENNReal.ofReal (gammaPDFReal a r x)).toReal
state_after: no goals
tactic: simp only [gammaMeasure, measurableSet_Iic, withDensity_apply, gammaPDF]
Theorem: Nat.cast_card_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
R : Type u_6
inst✝¹ : AddGroupWithOne R
inst✝ : Fintype R
⊢ ↑(card R) = 0
state_after: no goals
tactic: rw [← nsmul_one, card_nsmul_eq_zero]
Theorem: LocallyConstant.mapAddMonoidHom_apply
File: Mathlib/Topology/LocallyConstant/Algebra.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
α : Type u_3
R✝ : Type u_4
R : Type u_5
Z : Type u_6
inst✝¹ : MulOneClass Y
inst✝ : MulOneClass Z
f : Y →* Z
⊢ map (⇑f) 1 = 1
state_after: no goals
tactic: aesop
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
α : Type u_3
R✝ : Type u_4
R : Type u_5
Z : Type u_6
inst✝¹ : MulOneClass Y
inst✝ : MulOneClass Z
f : Y →* Z
⊢ ∀ (x y : LocallyConstant X Y),
    { toFun := map ⇑f, map_one' := ⋯ }.toFun (x * y) =
      { toFun := map ⇑f, map_one' := ⋯ }.toFun x * { toFun := map ⇑f, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: aesop
Theorem: isIrreducible_iff_sInter
File: Mathlib/Topology/Irreducible.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ IsIrreducible s ↔ ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty
state_after: case refine_1
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
h : IsIrreducible s
U : Finset (Set X)
hu : ∀ u ∈ U, IsOpen u
hU : ∀ u ∈ U, (s ∩ u).Nonempty
⊢ (s ∩ ⋂₀ ↑U).Nonempty

case refine_2
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
h : ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty
⊢ s.Nonempty

case refine_3
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
h : ∀ (U : Finset (Set X)), (∀ u ∈ U, IsOpen u) → (∀ u ∈ U, (s ∩ u).Nonempty) → (s ∩ ⋂₀ ↑U).Nonempty
⊢ IsPreirreducible s
tactic: refine ⟨fun h U hu hU => ?_, fun h => ⟨?_, ?_⟩⟩
Theorem: Multiset.map_univ
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ : Multiset α
β : Type u_2
m : Multiset α
f : α → β
⊢ map (fun x => f x.fst) Finset.univ.val = map f m
state_after: no goals
tactic: erw [← Multiset.map_map, Multiset.map_univ_coe]
Theorem: UniformConcaveOn.mono
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 → ℝ
hψφ : ψ ≤ φ
hf : UniformConcaveOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y + a * b * ψ ‖x - y‖ ≤ a • f x + b • f y + a * b * φ ‖x - y‖
state_after: case bc.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConcaveOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖
tactic: gcongr
state_before: case bc.h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hψφ : ψ ≤ φ
hf : UniformConcaveOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ψ ‖x - y‖ ≤ φ ‖x - y‖
state_after: no goals
tactic: apply hψφ
Theorem: Cardinal.mk_subtype_le_of_countable_eventually_mem_aux
File: Mathlib/SetTheory/Cardinal/CountableCover.lean

Proof steps:
state_before: α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : l.NeBot
t : Set α
ht : ∀ x ∈ t, ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
⊢ #↑t ≤ a
state_after: case inl
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : l.NeBot
t : Set α
ht : ∀ x ∈ t, ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : a < ℵ₀
⊢ #↑t ≤ a

case inr
α ι : Type u
a : Cardinal.{u}
inst✝¹ : Countable ι
f : ι → Set α
l : Filter ι
inst✝ : l.NeBot
t : Set α
ht : ∀ x ∈ t, ∀ᶠ (i : ι) in l, x ∈ f i
h'f : ∀ (i : ι), #↑(f i) ≤ a
ha : ℵ₀ ≤ a
⊢ #↑t ≤ a
tactic: rcases lt_or_le a ℵ₀ with ha|ha
Theorem: Submodule.Quotient.nontrivial_of_lt_top
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
⊢ Nontrivial (M ⧸ p)
state_after: case intro.intro
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : x ∉ p
⊢ Nontrivial (M ⧸ p)
tactic: obtain ⟨x, _, not_mem_s⟩ := SetLike.exists_of_lt h
state_before: case intro.intro
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : x ∉ p
⊢ Nontrivial (M ⧸ p)
state_after: case intro.intro
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : x ∉ p
⊢ mk x ≠ 0
tactic: refine ⟨⟨mk x, 0, ?_⟩⟩
state_before: case intro.intro
R : Type u_1
M : Type u_2
r : R
x✝ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : p < ⊤
x : M
left✝ : x ∈ ⊤
not_mem_s : x ∉ p
⊢ mk x ≠ 0
state_after: no goals
tactic: simpa using not_mem_s
Theorem: _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_norm_eq
File: Mathlib/NumberTheory/Padics/Hensel.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ ‖newton_seq (n + 1) - newton_seq n‖ =
    ‖Polynomial.eval (newton_seq n) F‖ / ‖Polynomial.eval (newton_seq n) (Polynomial.derivative F)‖
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ ‖↑(let_fun h1 := ⋯;
          let z1 :=
            ⟨↑(Polynomial.eval (↑(newton_seq_aux hnorm n)) F) /
                ↑(Polynomial.eval (↑(newton_seq_aux hnorm n)) (Polynomial.derivative F)),
              h1⟩;
          let z' := ↑(newton_seq_aux hnorm n) - z1;
          ⟨z', ⋯⟩) -
        ↑(newton_seq_aux hnorm n)‖ =
    ‖Polynomial.eval (↑(newton_seq_aux hnorm n)) F‖ /
      ‖Polynomial.eval (↑(newton_seq_aux hnorm n)) (Polynomial.derivative F)‖
tactic: rw [newton_seq_gen, newton_seq_gen, newton_seq_aux, ih_n]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
⊢ ‖↑(let_fun h1 := ⋯;
          let z1 :=
            ⟨↑(Polynomial.eval (↑(newton_seq_aux hnorm n)) F) /
                ↑(Polynomial.eval (↑(newton_seq_aux hnorm n)) (Polynomial.derivative F)),
              h1⟩;
          let z' := ↑(newton_seq_aux hnorm n) - z1;
          ⟨z', ⋯⟩) -
        ↑(newton_seq_aux hnorm n)‖ =
    ‖Polynomial.eval (↑(newton_seq_aux hnorm n)) F‖ /
      ‖Polynomial.eval (↑(newton_seq_aux hnorm n)) (Polynomial.derivative F)‖
state_after: no goals
tactic: simp [sub_eq_add_neg, add_comm]
Theorem: AlgebraicGeometry.LocallyRingedSpace.id_val
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X : LocallyRingedSpace
x : ↑↑X.toPresheafedSpace
⊢ IsLocalRingHom (PresheafedSpace.Hom.stalkMap (𝟙 X.toSheafedSpace) x)
state_after: X✝ X : LocallyRingedSpace
x : ↑↑X.toPresheafedSpace
⊢ IsLocalRingHom (𝟙 (X.presheaf.stalk x))
tactic: erw [PresheafedSpace.stalkMap.id]
state_before: X✝ X : LocallyRingedSpace
x : ↑↑X.toPresheafedSpace
⊢ IsLocalRingHom (𝟙 (X.presheaf.stalk x))
state_after: no goals
tactic: apply isLocalRingHom_id
Theorem: Filter.Eventually.ratCast_atBot
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in atBot, p ↑n
state_after: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atBot, p ↑n
tactic: rw [← Rat.comap_cast_atBot (R := R)]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : LinearOrderedField R
inst✝ : Archimedean R
p : R → Prop
h : ∀ᶠ (x : R) in atBot, p x
⊢ ∀ᶠ (n : ℚ) in Filter.comap Rat.cast atBot, p ↑n
state_after: no goals
tactic: exact h.comap _
Theorem: Orientation.rotation_eq_self_iff_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
hx : x ≠ 0
θ : Real.Angle
⊢ (o.rotation θ) x = x ↔ θ = 0
state_after: case mp
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
hx : x ≠ 0
θ : Real.Angle
⊢ (o.rotation θ) x = x → θ = 0

case mpr
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
hx : x ≠ 0
θ : Real.Angle
⊢ θ = 0 → (o.rotation θ) x = x
tactic: constructor
Theorem: AddCommGroup.neg_modEq_neg
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ -b ≡ -a [PMOD p] ↔ a ≡ b [PMOD p]
state_after: no goals
tactic: simp [ModEq, neg_add_eq_sub]
Theorem: Set.Nontrivial.infsep_lt_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ s.infsep < d ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ ¬s.infsep < d ↔ ¬∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d
tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ ¬s.infsep < d ↔ ¬∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ dist x y < d
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ d ≤ s.infsep ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ dist x y
tactic: push_neg
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
s t : Set α
d : ℝ
hs : s.Nontrivial
⊢ d ≤ s.infsep ↔ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ dist x y
state_after: no goals
tactic: exact hs.le_infsep_iff
Theorem: Batteries.RBNode.reverse_ins
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
t : RBNode α
⊢ (ins cmp x t).reverse = ins (flip cmp) x t.reverse
state_after: no goals
tactic: induction t <;> [skip; (rename_i c a y b iha ihb; cases c)] <;> simp [ins, flip]
    <;> rw [← inst.symm x y] <;> split <;> simp [*, Ordering.swap, iha, ihb]
Theorem: isNoetherian_of_range_eq_ker
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : IsNoetherian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N),
    Submodule.map ((LinearMap.ker f).liftQ f ⋯) (Submodule.comap ((LinearMap.ker f).liftQ f ⋯) a) =
      a ⊓ LinearMap.range f
state_after: no goals
tactic: simp [Submodule.map_comap_eq, inf_comm, Submodule.range_liftQ]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
inst✝³ : AddCommGroup P
inst✝² : Module R P
inst✝¹ : IsNoetherian R M
inst✝ : IsNoetherian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N), Submodule.comap g.rangeRestrict (Submodule.map g.rangeRestrict a) = a ⊔ LinearMap.range f
state_after: no goals
tactic: simp [Submodule.comap_map_eq, h]
Theorem: PNat.factorMultiset_one
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: ⊢ factorMultiset 1 = 0
state_after: no goals
tactic: simp [factorMultiset, PrimeMultiset.ofNatList, PrimeMultiset.ofNatMultiset]
Theorem: Rel.rightDual_mem_leftFixedPoint
File: Mathlib/Order/Rel/GaloisConnection.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Rel α β
I : Set β
⊢ R.rightDual I ∈ R.leftFixedPoints
state_after: case a
α : Type u_1
β : Type u_2
R : Rel α β
I : Set β
⊢ R.rightDual (R.leftDual (R.rightDual I)) ≤ R.rightDual I

case a
α : Type u_1
β : Type u_2
R : Rel α β
I : Set β
⊢ R.rightDual I ≤ R.rightDual (R.leftDual (R.rightDual I))
tactic: apply le_antisymm
Theorem: Matrix.col_injective
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Nonempty ι
⊢ Function.Injective (col ι)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Nonempty ι
inhabited_h : Inhabited ι
⊢ Function.Injective (col ι)
tactic: inhabit ι
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : Nonempty ι
inhabited_h : Inhabited ι
⊢ Function.Injective (col ι)
state_after: no goals
tactic: exact fun _x _y h => funext fun i => congr_fun₂ h i default
Theorem: Equiv.Perm.card_compl_support_modEq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p n : ℕ
hp : Fact (Nat.Prime p)
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ σ.supportᶜ.card ≡ Fintype.card α [MOD p]
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p n : ℕ
hp : Fact (Nat.Prime p)
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ p ∣ σ.cycleType.sum

α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p n : ℕ
hp : Fact (Nat.Prime p)
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ σ.supportᶜ.card ≤ Fintype.card α
tactic: rw [Nat.modEq_iff_dvd', ← Finset.card_compl, compl_compl, ← sum_cycleType]
Theorem: Real.sInf_smul_of_nonneg
File: Mathlib/Data/Real/Pointwise.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
⊢ sInf (a • s) = a • sInf s
state_after: case inl
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
⊢ sInf (a • ∅) = a • sInf ∅

case inr
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
⊢ sInf (a • s) = a • sInf s
tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: case inr
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
⊢ sInf (a • s) = a • sInf s
state_after: case inr.inl
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : s.Nonempty
ha : 0 ≤ 0
⊢ sInf (0 • s) = 0 • sInf s

case inr.inr
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
ha' : 0 < a
⊢ sInf (a • s) = a • sInf s
tactic: obtain rfl | ha' := ha.eq_or_lt
state_before: case inr.inr
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
ha' : 0 < a
⊢ sInf (a • s) = a • sInf s
state_after: case pos
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
ha' : 0 < a
h : BddBelow s
⊢ sInf (a • s) = a • sInf s

case neg
ι : Sort u_1
α : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : MulActionWithZero α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : 0 ≤ a
s : Set ℝ
hs : s.Nonempty
ha' : 0 < a
h : ¬BddBelow s
⊢ sInf (a • s) = a • sInf s
tactic: by_cases h : BddBelow s
Theorem: MvPolynomial.map_surjective
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f : R →+* S₁
hf : Surjective ⇑f
p : MvPolynomial σ S₁
⊢ ∃ a, (map f) a = p
state_after: case h1
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
hf : Surjective ⇑f
i : σ →₀ ℕ
fr : S₁
⊢ ∃ a, (map f) a = (monomial i) fr

case h2
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
hf : Surjective ⇑f
a b : MvPolynomial σ S₁
ha : ∃ a_1, (map f) a_1 = a
hb : ∃ a, (map f) a = b
⊢ ∃ a_1, (map f) a_1 = a + b
tactic: induction' p using MvPolynomial.induction_on' with i fr a b ha hb
Theorem: CategoryTheory.Free.embedding_map
File: Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => single f 1 }.map (f ≫ g) =
    { obj := fun X => X, map := fun {X Y} f => single f 1 }.map f ≫
      { obj := fun X => X, map := fun {X Y} f => single f 1 }.map g
state_after: R : Type u_1
inst✝¹ : CommRing R
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ single (f ≫ g) 1 = single f 1 ≫ single g 1
tactic: dsimp only []
state_before: R : Type u_1
inst✝¹ : CommRing R
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ single (f ≫ g) 1 = single f 1 ≫ single g 1
state_after: no goals
tactic: rw [single_comp_single, one_mul]