ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.MonoidalCategory.fullBraidedSubcategoryInclusion_map
File: Mathlib/CategoryTheory/Monoidal/Subcategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    inv ((fullMonoidalSubcategoryInclusion P).μ X Y) ≫
      (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
        (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
tactic: rw [IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: no goals
tactic: aesop_cat
Theorem: Nat.filter_range_nth_eq_insert
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
⊢ filter p (range (nth p (k + 1))) = insert (nth p k) (filter p (range (nth p k)))
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a ∈ insert (nth p k) (filter p (range (nth p k)))
⊢ a ∈ filter p (range (nth p (k + 1)))
tactic: refine (filter_range_nth_subset_insert p k).antisymm fun a ha => ?_
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a ∈ insert (nth p k) (filter p (range (nth p k)))
⊢ a ∈ filter p (range (nth p (k + 1)))
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a = nth p k ∨ a < nth p k ∧ p a
⊢ a < nth p (k + 1) ∧ p a
tactic: simp only [mem_insert, mem_filter, mem_range] at ha ⊢
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a = nth p k ∨ a < nth p k ∧ p a
⊢ a < nth p (k + 1) ∧ p a
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a = nth p k ∨ a < nth p k ∧ p a
this : nth p k < nth p (k + 1)
⊢ a < nth p (k + 1) ∧ p a
tactic: have : nth p k < nth p (k + 1) := nth_lt_nth' k.lt_succ_self hlt
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
ha : a = nth p k ∨ a < nth p k ∧ p a
this : nth p k < nth p (k + 1)
⊢ a < nth p (k + 1) ∧ p a
state_after: case inl
p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
this : nth p k < nth p (k + 1)
⊢ nth p k < nth p (k + 1) ∧ p (nth p k)

case inr.intro
p : ℕ → Prop
inst✝ : DecidablePred p
k : ℕ
hlt✝ : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card
a : ℕ
this : nth p k < nth p (k + 1)
hlt : a < nth p k
hpa : p a
⊢ a < nth p (k + 1) ∧ p a
tactic: rcases ha with (rfl | ⟨hlt, hpa⟩)
Theorem: Polynomial.Monic.add_of_right
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hq : q.Monic
hpq : p.degree < q.degree
⊢ (p + q).Monic
state_after: no goals
tactic: rwa [Monic, leadingCoeff_add_of_degree_lt hpq]
Theorem: Ideal.spanNorm_eq_bot_iff
File: Mathlib/RingTheory/Ideal/Norm.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : Module.Free R S
inst✝ : Module.Finite R S
I : Ideal S
⊢ spanNorm R I = ⊥ ↔ I = ⊥
state_after: R : Type u_1
inst✝⁶ : CommRing R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : Module.Free R S
inst✝ : Module.Finite R S
I : Ideal S
⊢ (∀ a ∈ I, a = 0) ↔ ∀ ⦃x : S⦄, x ∈ I → x ∈ ⊥
tactic: simp only [spanNorm, Ideal.span_eq_bot, Set.mem_image, SetLike.mem_coe, forall_exists_index,
    and_imp, forall_apply_eq_imp_iff₂,
    Algebra.norm_eq_zero_iff_of_basis (Module.Free.chooseBasis R S), @eq_bot_iff _ _ _ I,
    SetLike.le_def]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Type u_2
inst✝⁵ : CommRing S
inst✝⁴ : Algebra R S
inst✝³ : IsDomain R
inst✝² : IsDomain S
inst✝¹ : Module.Free R S
inst✝ : Module.Finite R S
I : Ideal S
⊢ (∀ a ∈ I, a = 0) ↔ ∀ ⦃x : S⦄, x ∈ I → x ∈ ⊥
state_after: no goals
tactic: rfl
Theorem: MvPolynomial.vars_monomial
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
h : r ≠ 0
⊢ ((monomial s) r).vars = s.support
state_after: no goals
tactic: classical rw [vars_def, degrees_monomial_eq _ _ h, Finsupp.toFinset_toMultiset]
Theorem: Fin.zero_mul'
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
inst✝ : NeZero n
k : Fin n
⊢ 0 * k = 0
state_after: no goals
tactic: simp [Fin.ext_iff, mul_def]
Theorem: isCompactOperator_iff_exists_mem_nhds_isCompact_closure_image
File: Mathlib/Analysis/Normed/Operator/Compact.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ IsCompactOperator f ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))
state_after: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ (∃ V ∈ 𝓝 0, ∃ K, IsCompact K ∧ f '' V ⊆ K) ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))
tactic: rw [isCompactOperator_iff_exists_mem_nhds_image_subset_compact]
state_before: R₁ : Type u_1
R₂ : Type u_2
inst✝⁵ : Semiring R₁
inst✝⁴ : Semiring R₂
σ₁₂ : R₁ →+* R₂
M₁ : Type u_3
M₂ : Type u_4
inst✝³ : TopologicalSpace M₁
inst✝² : AddCommMonoid M₁
inst✝¹ : TopologicalSpace M₂
inst✝ : T2Space M₂
f : M₁ → M₂
⊢ (∃ V ∈ 𝓝 0, ∃ K, IsCompact K ∧ f '' V ⊆ K) ↔ ∃ V ∈ 𝓝 0, IsCompact (closure (f '' V))
state_after: no goals
tactic: exact
    ⟨fun ⟨V, hV, K, hK, hKV⟩ => ⟨V, hV, hK.closure_of_subset hKV⟩,
      fun ⟨V, hV, hVc⟩ => ⟨V, hV, closure (f '' V), hVc, subset_closure⟩⟩
Theorem: UniqueDiffWithinAt.pi
File: Mathlib/Analysis/Calculus/TangentCone.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E✝ : Type u_2
inst✝⁸ : NormedAddCommGroup E✝
inst✝⁷ : NormedSpace 𝕜 E✝
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
x✝ y : E✝
s✝ t : Set E✝
ι : Type u_5
inst✝² : Finite ι
E : ι → Type u_6
inst✝¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝ : (i : ι) → NormedSpace 𝕜 (E i)
s : (i : ι) → Set (E i)
x : (i : ι) → E i
I : Set ι
h : ∀ i ∈ I, UniqueDiffWithinAt 𝕜 (s i) (x i)
⊢ UniqueDiffWithinAt 𝕜 (I.pi s) x
state_after: no goals
tactic: classical
  rw [← Set.univ_pi_piecewise_univ]
  refine UniqueDiffWithinAt.univ_pi ι E _ _ fun i => ?_
  by_cases hi : i ∈ I <;> simp [*, uniqueDiffWithinAt_univ]
Theorem: Associates.mul_eq_one_iff
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
x y : Associates α
a b : α
h : ⟦a⟧ * ⟦b⟧ = 1
this : a * b ~ᵤ 1
⊢ b * a ~ᵤ 1
state_after: no goals
tactic: rwa [mul_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CommMonoid α
x y : Associates α
⊢ x = 1 ∧ y = 1 → x * y = 1
state_after: no goals
tactic: simp (config := { contextual := true })
Theorem: Holor.mul_scalar_mul
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝ : Monoid α
x : Holor α []
y : Holor α ds
⊢ x ⊗ y = x ⟨[], ⋯⟩ • y
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) [mul, SMul.smul, HolorIndex.take, HolorIndex.drop,
    HSMul.hSMul]
Theorem: monomial_has_deriv_aux
File: Mathlib/Analysis/Calculus/Taylor.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (x - y) ^ (n + 1)) (-(↑n + 1) * (x - t) ^ n) t
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) (-(↑n + 1) * (-t + x) ^ n) t
tactic: simp_rw [sub_eq_neg_add]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) (-(↑n + 1) * (-t + x) ^ n) t
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) ((↑n + 1) * (-t + x) ^ n * -1) t
tactic: rw [← neg_one_mul, mul_comm (-1 : ℝ), mul_assoc, mul_comm (-1 : ℝ), ← mul_assoc]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ HasDerivAt (fun y => (-y + x) ^ (n + 1)) ((↑n + 1) * (-t + x) ^ n * -1) t
state_after: case h.e'_7.h.e'_5.h.e'_5
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ ↑n + 1 = ↑(n + 1)
tactic: convert HasDerivAt.pow (n + 1) ((hasDerivAt_id t).neg.add_const x)
state_before: case h.e'_7.h.e'_5.h.e'_5
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t x : ℝ
n : ℕ
⊢ ↑n + 1 = ↑(n + 1)
state_after: no goals
tactic: simp only [Nat.cast_add, Nat.cast_one]
Theorem: clusterPt_iff_not_disjoint
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
F : Filter X
⊢ ClusterPt x F ↔ ¬Disjoint (𝓝 x) F
state_after: no goals
tactic: rw [disjoint_iff, ClusterPt, neBot_iff]
Theorem: ArithmeticFunction.isMultiplicative_zeta
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
⊢ ζ 1 = 1
state_after: no goals
tactic: simp
state_before: R : Type u_1
⊢ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → ζ (m * n) = ζ m * ζ n
state_after: no goals
tactic: simp (config := { contextual := true })
Theorem: norm_combo_lt_of_ne
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hx : ‖x‖ ≤ r
hy : ‖y‖ ≤ r
hne : x ≠ y
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ ‖a • x + b • y‖ < r
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hne : x ≠ y
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx : x ∈ closedBall 0 r
hy : y ∈ closedBall 0 r
⊢ a • x + b • y ∈ ball 0 r
tactic: simp only [← mem_ball_zero_iff, ← mem_closedBall_zero_iff] at hx hy ⊢
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : NormedLinearOrderedField 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : StrictConvexSpace ℝ E
x y z : E
a b r : ℝ
hne : x ≠ y
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hx : x ∈ closedBall 0 r
hy : y ∈ closedBall 0 r
⊢ a • x + b • y ∈ ball 0 r
state_after: no goals
tactic: exact combo_mem_ball_of_ne hx hy hne ha hb hab
Theorem: Real.sin_sq_pi_over_two_pow
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
n : ℕ
⊢ sin (π / 2 ^ (n + 1)) ^ 2 = 1 - (sqrtTwoAddSeries 0 n / 2) ^ 2
state_after: no goals
tactic: rw [sin_sq, cos_pi_over_two_pow]
Theorem: MeasureTheory.measure_ne_zero_iff_nonempty_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H
inst✝⁵ : TopologicalSpace G
inst✝⁴ : BorelSpace G
μ : Measure G
inst✝³ : Group G
inst✝² : TopologicalGroup G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : μ.Regular
hμ : μ ≠ 0
s : Set G
hs : IsOpen s
⊢ μ s ≠ 0 ↔ s.Nonempty
state_after: no goals
tactic: simpa [null_iff_of_isMulLeftInvariant (μ := μ) hs, hμ] using nonempty_iff_ne_empty.symm
Theorem: Compactum.isClosed_iff
File: Mathlib/Topology/Category/Compactum.lean

Proof steps:
state_before: X : Compactum
S : Set X.A
⊢ IsClosed S ↔ ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S
state_after: X : Compactum
S : Set X.A
⊢ IsOpen Sᶜ ↔ ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S
tactic: rw [← isOpen_compl_iff]
state_before: X : Compactum
S : Set X.A
⊢ IsOpen Sᶜ ↔ ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S
state_after: case mp
X : Compactum
S : Set X.A
⊢ IsOpen Sᶜ → ∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S

case mpr
X : Compactum
S : Set X.A
⊢ (∀ (F : Ultrafilter X.A), S ∈ F → X.str F ∈ S) → IsOpen Sᶜ
tactic: constructor
Theorem: CategoryTheory.Sheaf.isSheaf_of_isLimit
File: Mathlib/CategoryTheory/Sites/Limits.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{w', w} D
K : Type z
inst✝¹ : Category.{z', z} K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
⊢ Presheaf.IsSheaf J E.pt
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{w', w} D
K : Type z
inst✝¹ : Category.{z', z} K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
⊢ ∀ (X : C) (S : J.Cover X), Nonempty (IsLimit (S.multifork E.pt))
tactic: rw [Presheaf.isSheaf_iff_multifork]
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{w', w} D
K : Type z
inst✝¹ : Category.{z', z} K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
⊢ ∀ (X : C) (S : J.Cover X), Nonempty (IsLimit (S.multifork E.pt))
state_after: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{w', w} D
K : Type z
inst✝¹ : Category.{z', z} K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
X : C
S : J.Cover X
⊢ Nonempty (IsLimit (S.multifork E.pt))
tactic: intro X S
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝² : Category.{w', w} D
K : Type z
inst✝¹ : Category.{z', z} K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
X : C
S : J.Cover X
⊢ Nonempty (IsLimit (S.multifork E.pt))
state_after: no goals
tactic: exact ⟨isLimitMultiforkOfIsLimit _ _ hE _ _⟩
Theorem: convexHull_add
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
s t : Set E
⊢ (convexHull R) (s + t) = (convexHull R) s + (convexHull R) t
state_after: no goals
tactic: simp_rw [← add_image_prod, ← IsLinearMap.isLinearMap_add.image_convexHull, convexHull_prod]
Theorem: Finset.centroid_eq_of_inj_on_of_image_eq
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
p : ι → P
hi : ∀ i ∈ s, ∀ j ∈ s, p i = p j → i = j
p₂ : ι₂ → P
hi₂ : ∀ i ∈ s₂, ∀ j ∈ s₂, p₂ i = p₂ j → i = j
he : p '' ↑s = p₂ '' ↑s₂
⊢ centroid k s p = centroid k s₂ p₂
state_after: no goals
tactic: classical rw [s.centroid_eq_centroid_image_of_inj_on k hi rfl,
      s₂.centroid_eq_centroid_image_of_inj_on k hi₂ he]
Theorem: DFinsupp.support_erase
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
⊢ (erase i f).support = f.support.erase i
state_after: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
tactic: ext j
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
state_after: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i

case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
tactic: by_cases h1 : j = i
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
i : ι
f : Π₀ (i : ι), β i
j : ι
h1 : ¬j = i
⊢ j ∈ (erase i f).support ↔ j ∈ f.support.erase i
state_after: no goals
tactic: by_cases h2 : f j ≠ 0 <;> simp at h2 <;> simp [h1, h2]
Theorem: ContinuousMap.toNNReal_add_add_neg_add_neg_eq
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
⊢ (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal = (-(f + g)).toNNReal + f.toNNReal + g.toNNReal
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f + g).toNNReal + (-f).toNNReal + (-g).toNNReal) x) = ↑(((-(f + g)).toNNReal + f.toNNReal + g.toNNReal) x)
tactic: ext x
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ ↑(((f + g).toNNReal + (-f).toNNReal + (-g).toNNReal) x) = ↑(((-(f + g)).toNNReal + f.toNNReal + g.toNNReal) x)
state_after: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x + g x) 0 + (-f x + max (f x) 0) + (-g x + max (g x) 0) =
    -(f x + g x) + max (f x + g x) 0 + max (f x) 0 + max (g x) 0
tactic: simp [max_neg_zero, -neg_add_rev]
state_before: case h.a
X : Type u_1
inst✝ : TopologicalSpace X
f g : C(X, ℝ)
x : X
⊢ max (f x + g x) 0 + (-f x + max (f x) 0) + (-g x + max (g x) 0) =
    -(f x + g x) + max (f x + g x) 0 + max (f x) 0 + max (g x) 0
state_after: no goals
tactic: abel
Theorem: Cardinal.one_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
⊢ 1 < ℵ₀
state_after: no goals
tactic: simpa using nat_lt_aleph0 1
Theorem: Ordinal.bsup_eq_blsub_iff_lt_bsup
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
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
h : o.bsup f = o.blsub f
i : Ordinal.{u}
⊢ ∀ (hi : i < o), f i hi < o.bsup f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
h : o.bsup f = o.blsub f
i : Ordinal.{u}
⊢ ∀ (hi : i < o), f i hi < o.blsub f
tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
h : o.bsup f = o.blsub f
i : Ordinal.{u}
⊢ ∀ (hi : i < o), f i hi < o.blsub f
state_after: no goals
tactic: apply lt_blsub
Theorem: CircleDeg1Lift.isUnit_iff_bijective
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ⇑f
x y : ℝ
hxy : x ≤ y
⊢ f ((Equiv.ofBijective (⇑f) h).symm x) ≤ f ((Equiv.ofBijective (⇑f) h).symm y)
state_after: no goals
tactic: simp only [Equiv.ofBijective_apply_symm_apply f h, hxy]
state_before: f✝ g f : CircleDeg1Lift
h : Bijective ⇑f
x : ℝ
⊢ f ({ toFun := ⇑(Equiv.ofBijective (⇑f) h).symm, monotone' := ⋯ }.toFun (x + 1)) =
    f ({ toFun := ⇑(Equiv.ofBijective (⇑f) h).symm, monotone' := ⋯ }.toFun x + 1)
state_after: no goals
tactic: simp only [Equiv.ofBijective_apply_symm_apply f, f.map_add_one]
Theorem: CochainComplex.HomComplex.Cochain.ofHom_neg
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
φ : F ⟶ G
⊢ ofHom (-φ) = -ofHom φ
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.FunctorToTypes.binaryProductLimit_lift
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
x✝¹ : Cone (pair F G)
x✝ : x✝¹.pt ⟶ (binaryProductCone F G).pt
h : ∀ (j : Discrete WalkingPair), x✝ ≫ (binaryProductCone F G).π.app j = x✝¹.π.app j
⊢ x✝ = (fun s => prod.lift s.fst s.snd) x✝¹
state_after: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
x✝¹ : Cone (pair F G)
x✝ : x✝¹.pt ⟶ (binaryProductCone F G).pt
h : ∀ (j : Discrete WalkingPair), x✝ ≫ (binaryProductCone F G).π.app j = x✝¹.π.app j
⊢ x✝ =
    prod.lift (x✝ ≫ (binaryProductCone F G).π.app { as := WalkingPair.left })
      (x✝ ≫ (binaryProductCone F G).π.app { as := WalkingPair.right })
tactic: simp only [← h ⟨WalkingPair.right⟩, ← h ⟨WalkingPair.left⟩]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
x✝¹ : Cone (pair F G)
x✝ : x✝¹.pt ⟶ (binaryProductCone F G).pt
h : ∀ (j : Discrete WalkingPair), x✝ ≫ (binaryProductCone F G).π.app j = x✝¹.π.app j
⊢ x✝ =
    prod.lift (x✝ ≫ (binaryProductCone F G).π.app { as := WalkingPair.left })
      (x✝ ≫ (binaryProductCone F G).π.app { as := WalkingPair.right })
state_after: no goals
tactic: congr
Theorem: Fin.map_valEmbedding_univ
File: Mathlib/Data/Fintype/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
⊢ map valEmbedding univ = Iio n
state_after: case a
α : Type u_1
β : Type u_2
n a✝ : ℕ
⊢ a✝ ∈ map valEmbedding univ ↔ a✝ ∈ Iio n
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
n a✝ : ℕ
⊢ a✝ ∈ map valEmbedding univ ↔ a✝ ∈ Iio n
state_after: no goals
tactic: simp [orderIsoSubtype.symm.surjective.exists, OrderIso.symm]
Theorem: NNRat.cast_nonpos
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
K : Type u_5
inst✝ : LinearOrderedSemifield K
p q : ℚ≥0
⊢ ↑q ≤ 0 ↔ q ≤ 0
state_after: no goals
tactic: norm_cast