ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.prod_apply
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
x y : M
⊢ Pi.prod (⇑f) (⇑g) (x + y) = Pi.prod (⇑f) (⇑g) x + Pi.prod (⇑f) (⇑g) y
state_after: no goals
tactic: simp only [Pi.prod, Prod.mk_add_mk, map_add]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f✝ f : M →ₗ[R] M₂
g : M →ₗ[R] M₃
c : R
x : M
⊢ { toFun := Pi.prod ⇑f ⇑g, map_add' := ⋯ }.toFun (c • x) =
    (RingHom.id R) c • { toFun := Pi.prod ⇑f ⇑g, map_add' := ⋯ }.toFun x
state_after: no goals
tactic: simp only [Pi.prod, Prod.smul_mk, map_smul, RingHom.id_apply]
Theorem: Set.Icc.coe_eq_one
File: Mathlib/Algebra/Order/Interval/Set/Instances.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ ↑x = 1 ↔ x = 1
state_after: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 1 ↔ ↑x = 1
tactic: symm
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 1 ↔ ↑x = 1
state_after: no goals
tactic: exact Subtype.ext_iff
Theorem: Ordinal.IsFundamentalSequence.monotone
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
i j : Ordinal.{u}
hi : i < o
hj : j < o
hij : i ≤ j
⊢ f i hi ≤ f j hj
state_after: case inl
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
i j : Ordinal.{u}
hi : i < o
hj : j < o
hij✝ : i ≤ j
hij : i < j
⊢ f i hi ≤ f j hj

case inr
α : Type u_1
r : α → α → Prop
a o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{u}
hf : a.IsFundamentalSequence o f
i : Ordinal.{u}
hi hj : i < o
hij : i ≤ i
⊢ f i hi ≤ f i hj
tactic: rcases lt_or_eq_of_le hij with (hij | rfl)
Theorem: Algebra.sInf_toSubmodule
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Set (Subalgebra R A)
⊢ ↑(Subalgebra.toSubmodule (sInf S)) = ↑(sInf (⇑Subalgebra.toSubmodule '' S))
state_after: no goals
tactic: simp
Theorem: Stream'.WSeq.LiftRel.symm
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
H : Symmetric R
s1 s2 : WSeq α
h : Function.swap (LiftRel R) s2 s1
⊢ LiftRel R s2 s1
state_after: no goals
tactic: rwa [LiftRel.swap, H.swap_eq] at h
Theorem: CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_obj
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ ∀ (j : WalkingParallelPair), K₁.toSigmaCofork.ι.app j ≫ f.hom = K₂.toSigmaCofork.ι.app j
state_after: case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.zero ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.zero

case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.one ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.one
tactic: rintro (_|_)
state_before: case zero
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.zero ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.zero

case one
C : Type u
inst✝² : Category.{v, u} C
I : MultispanIndex C
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
K₁ K₂ : Multicofork I
f : K₁ ⟶ K₂
⊢ K₁.toSigmaCofork.ι.app WalkingParallelPair.one ≫ f.hom = K₂.toSigmaCofork.ι.app WalkingParallelPair.one
state_after: no goals
tactic: all_goals {
        apply colimit.hom_ext
        rintro ⟨j⟩
        simp }
Theorem: Finset.prod_union
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁ ∪ s₂, f x = (∏ x ∈ s₁, f x) * ∏ x ∈ s₂, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁ ∪ s₂, f x = (∏ x ∈ s₁ ∪ s₂, f x) * ∏ x ∈ ∅, f x
tactic: rw [← prod_union_inter, disjoint_iff_inter_eq_empty.mp h]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : Disjoint s₁ s₂
⊢ ∏ x ∈ s₁ ∪ s₂, f x = (∏ x ∈ s₁ ∪ s₂, f x) * ∏ x ∈ ∅, f x
state_after: no goals
tactic: exact (mul_one _).symm
Theorem: HahnSeries.leadingCoeff_one
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝² : Zero Γ
inst✝¹ : PartialOrder Γ
inst✝ : MulZeroOneClass R
⊢ leadingCoeff 1 = 1
state_after: no goals
tactic: simp [leadingCoeff_eq]
Theorem: NNReal.mul_eq_mul_left
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: a b c : ℝ≥0
h : a ≠ 0
⊢ a * b = a * c ↔ b = c
state_after: no goals
tactic: rw [mul_eq_mul_left_iff, or_iff_left h]
Theorem: Polynomial.map_mod_divByMonic
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
tactic: nontriviality S
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
this : Nontrivial R
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
tactic: haveI : Nontrivial R := f.domain_nontrivial
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
this : Nontrivial R
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
this✝ : Nontrivial R
this : map f p /ₘ map f q = map f (p /ₘ q) ∧ map f p %ₘ map f q = map f (p %ₘ q)
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
tactic: have : map f p /ₘ map f q = map f (p /ₘ q) ∧ map f p %ₘ map f q = map f (p %ₘ q) :=
    div_modByMonic_unique ((p /ₘ q).map f) _ (hq.map f)
      ⟨Eq.symm <| by rw [← Polynomial.map_mul, ← Polynomial.map_add, modByMonic_add_div _ hq],
        calc
          _ ≤ degree (p %ₘ q) := degree_map_le _ _
          _ < degree q := degree_modByMonic_lt _ hq
          _ = _ :=
            Eq.symm <|
              degree_map_eq_of_leadingCoeff_ne_zero _
                (by rw [Monic.def.1 hq, f.map_one]; exact one_ne_zero)⟩
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : Ring R
p q : R[X]
inst✝ : Ring S
f : R →+* S
hq : q.Monic
a✝ : Nontrivial S
this✝ : Nontrivial R
this : map f p /ₘ map f q = map f (p /ₘ q) ∧ map f p %ₘ map f q = map f (p %ₘ q)
⊢ map f (p /ₘ q) = map f p /ₘ map f q ∧ map f (p %ₘ q) = map f p %ₘ map f q
state_after: no goals
tactic: exact ⟨this.1.symm, this.2.symm⟩
Theorem: BoxIntegral.Box.upper_sub_lower_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
I✝ J I : Box ι
s : Set ι
i : ι
⊢ (I.splitCenterBox s).upper i - (I.splitCenterBox s).lower i = (I.upper i - I.lower i) / 2
state_after: no goals
tactic: by_cases i ∈ s <;> field_simp [splitCenterBox] <;> field_simp [mul_two, two_mul]
Theorem: Orientation.right_ne_zero_of_oangle_sign_eq_one
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.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 y : V
h : (o.oangle x y).sign = 1
⊢ 1 ≠ 0
state_after: no goals
tactic: decide
Theorem: SimpleGraph.CliqueFree.mono
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : m ≤ n
⊢ G.CliqueFree m → G.CliqueFree n
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : G.CliqueFree m
s : Finset α
hs : G.IsNClique n s
⊢ False
tactic: intro hG s hs
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : G.CliqueFree m
s : Finset α
hs : G.IsNClique n s
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : G.CliqueFree m
s : Finset α
hs : G.IsNClique n s
t : Finset α
hts : t ⊆ s
ht : t.card = m
⊢ False
tactic: obtain ⟨t, hts, ht⟩ := exists_subset_card_eq (h.trans hs.card_eq.ge)
state_before: case intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : G.CliqueFree m
s : Finset α
hs : G.IsNClique n s
t : Finset α
hts : t ⊆ s
ht : t.card = m
⊢ False
state_after: no goals
tactic: exact hG _ ⟨hs.clique.subset hts, ht⟩
Theorem: Filter.HasBasis.le_iff
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
⊢ l ≤ l' ↔ ∀ t ∈ l', ∃ i, p i ∧ s i ⊆ t
state_after: no goals
tactic: simp only [le_def, hl.mem_iff]
Theorem: Mathlib.Meta.NormNum.IsInt.neg_to_eq
File: Mathlib/Tactic/NormNum/Result.lean

Proof steps:
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
n : ℕ
⊢ ↑(Int.negOfNat n) = -↑n
state_after: no goals
tactic: simp [Int.negOfNat_eq, Int.cast_neg]
Theorem: nonempty_sections_of_finite_inverse_system
File: Mathlib/CategoryTheory/CofilteredSystem.lean

Proof steps:
state_before: J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), Nonempty (F.obj j)
⊢ F.sections.Nonempty
state_after: case inl
J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), Nonempty (F.obj j)
h✝ : IsEmpty J
⊢ F.sections.Nonempty

case inr
J : Type u
inst✝³ : Preorder J
inst✝² : IsDirected J fun x x_1 => x ≤ x_1
F : Jᵒᵖ ⥤ Type v
inst✝¹ : ∀ (j : Jᵒᵖ), Finite (F.obj j)
inst✝ : ∀ (j : Jᵒᵖ), Nonempty (F.obj j)
h✝ : Nonempty J
⊢ F.sections.Nonempty
tactic: cases isEmpty_or_nonempty J
Theorem: StrictMonoOn.eq_iff_eq
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b → f a = f b
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a : α
ha hb : a ∈ s
⊢ f a = f a
tactic: rintro rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : LinearOrder α
inst✝ : Preorder β
f : α → β
s : Set α
hf : StrictMonoOn f s
a : α
ha hb : a ∈ s
⊢ f a = f a
state_after: no goals
tactic: rfl
Theorem: Bool.xor_iff_ne
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {x y : Bool}, xor x y = true ↔ x ≠ y
state_after: no goals
tactic: decide
Theorem: Equiv.Perm.zpow_apply_mem_support
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
n : ℤ
x : α
⊢ (f ^ n) x ∈ f.support ↔ x ∈ f.support
state_after: no goals
tactic: simp only [mem_support, ne_eq, apply_zpow_apply_eq_iff]
Theorem: CategoryTheory.Limits.limit_obj_ext
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f = g
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom
tactic: apply (cancel_mono (limitObjIsoLimitCompEvaluation H k).hom).1
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j
tactic: ext j
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ (limit.π H j).app k = g ≫ (limit.π H j).app k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j
state_after: no goals
tactic: simpa using w j
Theorem: IsSimpleOrder.equivBool_symm_apply
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝⁷ : DecidableEq α✝
inst✝⁶ : PartialOrder α✝
inst✝⁵ : BoundedOrder α✝
inst✝⁴ : IsSimpleOrder α✝
α : Type ?u.83175
inst✝³ : DecidableEq α
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
x : α
⊢ (fun x => Bool.casesOn x ⊥ ⊤) ((fun x => decide (x = ⊤)) x) = x
state_after: no goals
tactic: rcases eq_bot_or_eq_top x with (rfl | rfl) <;> simp [bot_ne_top]
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝⁷ : DecidableEq α✝
inst✝⁶ : PartialOrder α✝
inst✝⁵ : BoundedOrder α✝
inst✝⁴ : IsSimpleOrder α✝
α : Type ?u.83175
inst✝³ : DecidableEq α
inst✝² : LE α
inst✝¹ : BoundedOrder α
inst✝ : IsSimpleOrder α
x : Bool
⊢ (fun x => decide (x = ⊤)) ((fun x => Bool.casesOn x ⊥ ⊤) x) = x
state_after: no goals
tactic: cases x <;> simp [bot_ne_top]
Theorem: Matroid.uniqueBaseOn_indep_iff
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
hIE : I ⊆ E
⊢ (uniqueBaseOn I E).Indep J ↔ J ⊆ I
state_after: α : Type u_1
M : Matroid α
E B I X R J : Set α
hIE : I ⊆ E
⊢ J ⊆ I → J ⊆ E
tactic: rw [uniqueBaseOn, restrict_indep_iff, freeOn_indep_iff, and_iff_left_iff_imp]
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
hIE : I ⊆ E
⊢ J ⊆ I → J ⊆ E
state_after: no goals
tactic: exact fun h ↦ h.trans hIE
Theorem: Nat.iSup_le_succ'
File: Mathlib/Data/Nat/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ⨆ k, ⨆ (_ : k ≤ n + 1), u k = u 0 ⊔ ⨆ k, ⨆ (_ : k ≤ n), u (k + 1)
state_after: no goals
tactic: simp_rw [← Nat.lt_succ_iff, iSup_lt_succ']
Theorem: SimpleGraph.map_le_of_subsingleton
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : V ↪ W
inst✝ : Subsingleton V
⊢ SimpleGraph.map f G ≤ G'
state_after: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : V ↪ W
inst✝ : Subsingleton V
⊢ G ≤ SimpleGraph.comap (⇑f) G'
tactic: rw [map_le_iff_le_comap]
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
f : V ↪ W
inst✝ : Subsingleton V
⊢ G ≤ SimpleGraph.comap (⇑f) G'
state_after: no goals
tactic: apply le_comap_of_subsingleton
Theorem: Fin.succAbove_ne
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
⊢ p.succAbove i ≠ p
state_after: case inl
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : i.castSucc < p
⊢ p.succAbove i ≠ p

case inr
n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p : Fin (n + 1)
i : Fin n
h : p < i.succ
⊢ p.succAbove i ≠ p
tactic: rcases p.castSucc_lt_or_lt_succ i with (h | h)
Theorem: MeasureTheory.memℒp_two_iff_integrable_sq_norm
File: Mathlib/MeasureTheory/Function/L2Space.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 μ ↔ Integrable (fun x => ‖f x‖ ^ 2) μ
state_after: α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 μ ↔ Memℒp (fun x => ‖f x‖ ^ 2) 1 μ
tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ Memℒp f 2 μ ↔ Memℒp (fun x => ‖f x‖ ^ 2) 1 μ
state_after: case h.e'_2.h.e'_5.h
α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
x✝ : α
⊢ ‖f x✝‖ ^ 2 = ‖f x✝‖ ^ ENNReal.toReal 2

case h.e'_2.h.e'_6
α : Type u_1
F : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup F
f : α → F
hf : AEStronglyMeasurable f μ
⊢ 1 = 2 / 2
tactic: convert (memℒp_norm_rpow_iff hf two_ne_zero ENNReal.two_ne_top).symm
Theorem: MeasureTheory.continuousWithinAt_of_dominated
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F✝ : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F✝
inst✝⁵ : NormedSpace ℝ F✝
inst✝⁴ : CompleteSpace F✝
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → G
x₀ : X
bound : α → ℝ
s : Set X
hF_meas : ∀ᶠ (x : X) in 𝓝[s] x₀, AEStronglyMeasurable (F x) μ
h_bound : ∀ᶠ (x : X) in 𝓝[s] x₀, ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_cont : ∀ᵐ (a : α) ∂μ, ContinuousWithinAt (fun x => F x a) s x₀
⊢ ContinuousWithinAt (fun x => ∫ (a : α), F x a ∂μ) s x₀
state_after: case pos
α : Type u_1
E : Type u_2
F✝ : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F✝
inst✝⁵ : NormedSpace ℝ F✝
inst✝⁴ : CompleteSpace F✝
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → G
x₀ : X
bound : α → ℝ
s : Set X
hF_meas : ∀ᶠ (x : X) in 𝓝[s] x₀, AEStronglyMeasurable (F x) μ
h_bound : ∀ᶠ (x : X) in 𝓝[s] x₀, ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_cont : ∀ᵐ (a : α) ∂μ, ContinuousWithinAt (fun x => F x a) s x₀
hG : CompleteSpace G
⊢ ContinuousWithinAt (fun x => ∫ (a : α), F x a ∂μ) s x₀

case neg
α : Type u_1
E : Type u_2
F✝ : Type u_3
𝕜 : Type u_4
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : SMulCommClass ℝ 𝕜 E
inst✝⁶ : NormedAddCommGroup F✝
inst✝⁵ : NormedSpace ℝ F✝
inst✝⁴ : CompleteSpace F✝
G : Type u_5
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace ℝ G
f g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → G
x₀ : X
bound : α → ℝ
s : Set X
hF_meas : ∀ᶠ (x : X) in 𝓝[s] x₀, AEStronglyMeasurable (F x) μ
h_bound : ∀ᶠ (x : X) in 𝓝[s] x₀, ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_cont : ∀ᵐ (a : α) ∂μ, ContinuousWithinAt (fun x => F x a) s x₀
hG : ¬CompleteSpace G
⊢ ContinuousWithinAt (fun x => ∫ (a : α), F x a ∂μ) s x₀
tactic: by_cases hG : CompleteSpace G
Theorem: WithTop.coe_sSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
hb : BddAbove s
⊢ ↑(sSup s) = ⨆ a ∈ s, ↑a
state_after: no goals
tactic: rw [coe_sSup' hb, sSup_image]
Theorem: SimpleGraph.Walk.IsPath.of_map
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f✝ : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
f : G →g G'
hp : (Walk.map f p).IsPath
⊢ p.IsPath
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons _ _ ih =>
    rw [map_cons, Walk.cons_isPath_iff, support_map] at hp
    rw [Walk.cons_isPath_iff]
    cases' hp with hp1 hp2
    refine ⟨ih hp1, ?_⟩
    contrapose! hp2
    exact List.mem_map_of_mem f hp2