ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.leadingCoeff_quadratic
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X ^ 2 + C b * X + C c).leadingCoeff = a
state_after: no goals
tactic: rw [add_assoc, add_comm, leadingCoeff_add_of_degree_lt <| degree_linear_lt_degree_C_mul_X_sq ha,
    leadingCoeff_C_mul_X_pow]
Theorem: Real.sign_intCast
File: Mathlib/Data/Real/Sign.lean

Proof steps:
state_before: z : ℤ
⊢ (↑z).sign = ↑z.sign
state_after: case inl
z : ℤ
hn : z < 0
⊢ (↑z).sign = ↑z.sign

case inr.inl

⊢ (↑0).sign = ↑(Int.sign 0)

case inr.inr
z : ℤ
hp : 0 < z
⊢ (↑z).sign = ↑z.sign
tactic: obtain hn | rfl | hp := lt_trichotomy z (0 : ℤ)
Theorem: mul_sub_mul_div_mul_nonpos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c ≠ 0
hd : d ≠ 0
⊢ (a * d - b * c) / (c * d) ≤ 0 ↔ a / c ≤ b / d
state_after: no goals
tactic: rw [mul_comm b c, ← div_sub_div _ _ hc hd, sub_nonpos]
Theorem: Fin.cons_le_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y✝ : α i.succ
z : α 0
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
x₀ y₀ : α 0
x y : (i : Fin n) → α i.succ
⊢ (∀ (i : Fin n), cons x₀ x i.succ ≤ cons y₀ y i.succ) ↔ x ≤ y
state_after: no goals
tactic: simp only [cons_succ, Pi.le_def]
Theorem: CategoryTheory.OverPresheafAux.counitBackward_counitForward
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F✝ : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
s : CostructuredArrow yoneda A
x : F.obj (op s)
⊢ (counitBackward F s ∘ counitForward F s) x = id x
state_after: no goals
tactic: simp [counitBackward]
Theorem: Matrix.conjTranspose_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝³ : DecidableEq n'
inst✝² : Fintype n'
R : Type u_2
inst✝¹ : CommRing R
inst✝ : StarRing R
A : M
n : ℕ
⊢ (A ^ ↑n)ᴴ = Aᴴ ^ ↑n
state_after: no goals
tactic: rw [zpow_natCast, zpow_natCast, conjTranspose_pow]
state_before: n' : Type u_1
inst✝³ : DecidableEq n'
inst✝² : Fintype n'
R : Type u_2
inst✝¹ : CommRing R
inst✝ : StarRing R
A : M
n : ℕ
⊢ (A ^ -[n+1])ᴴ = Aᴴ ^ -[n+1]
state_after: no goals
tactic: rw [zpow_negSucc, zpow_negSucc, conjTranspose_nonsing_inv, conjTranspose_pow]
Theorem: CategoryTheory.Functor.OfSequence.map_comp
File: Mathlib/CategoryTheory/Functor/OfSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
i j k : ℕ
hij : i ≤ j
hjk : j ≤ k
⊢ map f i k ⋯ = map f i j hij ≫ map f j k hjk
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
i : ℕ
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)) (j k : ℕ) (hij : i ≤ j) (hjk : j ≤ k),
    map f i k ⋯ = map f i j hij ≫ map f j k hjk
tactic: revert X f j k
Theorem: MeasureTheory.supermartingale_nat
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale f 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale (- -f) 𝒢 μ
tactic: rw [← neg_neg f]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
⊢ Supermartingale (- -f) 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
i : ℕ
⊢ (-f) i ≤ᶠ[ae μ] -μ[f (i + 1)|↑𝒢 i]
tactic: refine (submartingale_nat hadp.neg (fun i => (hint i).neg) fun i =>
    EventuallyLE.trans ?_ (condexp_neg _).symm.le).neg
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), μ[f (i + 1)|↑𝒢 i] ≤ᶠ[ae μ] f i
i : ℕ
⊢ (-f) i ≤ᶠ[ae μ] -μ[f (i + 1)|↑𝒢 i]
state_after: no goals
tactic: filter_upwards [hf i] with x hx using neg_le_neg hx
Theorem: Finset.insert_union
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ insert a s ∪ t = insert a (s ∪ t)
state_after: no goals
tactic: simp only [insert_eq, union_assoc]
Theorem: Fin.isThreeCycle_cycleRange_two
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
⊢ (cycleRange 2).IsThreeCycle
state_after: no goals
tactic: rw [IsThreeCycle, cycleType_cycleRange] <;> simp [Fin.ext_iff]
Theorem: rotation_trans
File: Mathlib/Analysis/Complex/Isometry.lean

Proof steps:
state_before: a b : ↥circle
⊢ (rotation a).trans (rotation b) = rotation (b * a)
state_after: case h
a b : ↥circle
x✝ : ℂ
⊢ ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝
tactic: ext1
state_before: case h
a b : ↥circle
x✝ : ℂ
⊢ ((rotation a).trans (rotation b)) x✝ = (rotation (b * a)) x✝
state_after: no goals
tactic: simp
Theorem: TopologicalSpace.Opens.mapIso_inv_app
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X Y Z : TopCat
f g : X ⟶ Y
h : f = g
U : Opens ↑Y
⊢ (map g).obj U = (map f).obj U
state_after: no goals
tactic: rw [h]
Theorem: List.countP_true
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP (fun x => true) l = l.length
state_after: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → true = true
tactic: rw [countP_eq_length]
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ ∀ (a : α), a ∈ l → true = true
state_after: no goals
tactic: simp
Theorem: LieSubmodule.mem_lieSpan
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ lieSpan R L s ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
state_after: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ ↑(lieSpan R L s) ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
tactic: change x ∈ (lieSpan R L s : Set M) ↔ _
state_before: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ ↑(lieSpan R L s) ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
state_after: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ ⋂ s_1 ∈ {N | s ⊆ ↑N}, ↑s_1 ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
tactic: erw [sInf_coe]
state_before: R : Type u
L : Type v
M : Type w
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
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
x : M
⊢ x ∈ ⋂ s_1 ∈ {N | s ⊆ ↑N}, ↑s_1 ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N
state_after: no goals
tactic: exact mem_iInter₂
Theorem: MeasureTheory.toOuterMeasure_trim_eq_trim_toOuterMeasure
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ✝ : Measure α
s : Set α
μ : Measure α
hm : m ≤ m0
⊢ (μ.trim hm).toOuterMeasure = μ.trim
state_after: no goals
tactic: rw [Measure.trim, toMeasure_toOuterMeasure (ms := m)]
Theorem: compl_eq_comm
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ xᶜ = y ↔ yᶜ = x
state_after: no goals
tactic: rw [eq_comm, compl_eq_iff_isCompl, eq_compl_iff_isCompl]
Theorem: Real.lt_logb_iff_rpow_lt
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hb : 1 < b
hy : 0 < y
⊢ x < logb b y ↔ b ^ x < y
state_after: no goals
tactic: rw [← rpow_lt_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hy]
Theorem: Finsupp.toMultiset_sum_single
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
s : Finset ι
n : ℕ
⊢ toMultiset (∑ i ∈ s, single i n) = n • s.val
state_after: no goals
tactic: simp_rw [toMultiset_sum, Finsupp.toMultiset_single, sum_nsmul, sum_multiset_singleton]
Theorem: coborder_eq_union_frontier_compl
File: Mathlib/Topology/LocallyClosed.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
⊢ coborder s = s ∪ (frontier s)ᶜ
state_after: no goals
tactic: rw [coborder, compl_eq_comm, compl_union, compl_compl, ← diff_eq_compl_inter,
    ← union_diff_right, union_comm, ← closure_eq_self_union_frontier]
Theorem: Polynomial.Chebyshev.T_sub_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ T R (n - 2) = 2 * X * T R (n - 1) - T R n
state_after: no goals
tactic: linear_combination (norm := ring_nf) T_add_two R (n - 2)
Theorem: ContinuousMonoidHom.toContinuousMap_injective
File: Mathlib/Topology/Algebra/ContinuousMonoidHom.lean

Proof steps:
state_before: F : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
D : Type u_5
E : Type u_6
inst✝¹⁰ : Monoid A
inst✝⁹ : Monoid B
inst✝⁸ : Monoid C
inst✝⁷ : Monoid D
inst✝⁶ : CommGroup E
inst✝⁵ : TopologicalSpace A
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace C
inst✝² : TopologicalSpace D
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalGroup E
f g : ContinuousMonoidHom A B
h : f.toContinuousMap = g.toContinuousMap
⊢ ∀ (x : A), f x = g x
state_after: no goals
tactic: convert DFunLike.ext_iff.1 h
Theorem: Mon_.limitCone_π_app_hom
File: Mathlib/CategoryTheory/Monoidal/Internal/Limits.lean

Proof steps:
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
j j' : J
f : j ⟶ j'
⊢ ((Functor.const J).obj (limit F)).map f ≫
      (fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j' =
    (fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j ≫ F.map f
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
j j' : J
f : j ⟶ j'
⊢ (((Functor.const J).obj (limit F)).map f ≫
        (fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j').hom =
    ((fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j ≫ F.map f).hom
tactic: ext
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F : J ⥤ Mon_ C
j j' : J
f : j ⟶ j'
⊢ (((Functor.const J).obj (limit F)).map f ≫
        (fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j').hom =
    ((fun j => { hom := limit.π (F ⋙ forget C) j, one_hom := ⋯, mul_hom := ⋯ }) j ≫ F.map f).hom
state_after: no goals
tactic: exact (limit.cone (F ⋙ Mon_.forget C)).π.naturality f
Theorem: TopCat.Presheaf.stalkCongr_inv
File: Mathlib/Topology/Sheaves/Stalks.lean

Proof steps:
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
X : TopCat
C : Type u_1
inst✝¹ : Category.{?u.436644, u_1} C
inst✝ : HasColimits C
F : Presheaf C X
x y : ↑X
e : Inseparable x y
⊢ F.stalkSpecializes ⋯ ≫ F.stalkSpecializes ⋯ = 𝟙 (F.stalk x)
state_after: no goals
tactic: simp
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
X : TopCat
C : Type u_1
inst✝¹ : Category.{?u.436644, u_1} C
inst✝ : HasColimits C
F : Presheaf C X
x y : ↑X
e : Inseparable x y
⊢ F.stalkSpecializes ⋯ ≫ F.stalkSpecializes ⋯ = 𝟙 (F.stalk y)
state_after: no goals
tactic: simp
Theorem: Real.one_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 < x ^ z
state_after: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 ^ z < x ^ z
tactic: rw [← one_rpow z]
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 ^ z < x ^ z
state_after: no goals
tactic: exact rpow_lt_rpow zero_le_one hx hz
Theorem: OrthogonalFamily.isInternal_iff_of_isComplete
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
ι : Type u_4
inst✝ : DecidableEq ι
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ
hc : IsComplete ↑(iSup V)
⊢ DirectSum.IsInternal V ↔ (iSup V)ᗮ = ⊥
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
ι : Type u_4
inst✝ : DecidableEq ι
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ
hc : IsComplete ↑(iSup V)
this : CompleteSpace ↥(iSup V)
⊢ DirectSum.IsInternal V ↔ (iSup V)ᗮ = ⊥
tactic: haveI : CompleteSpace (↥(iSup V)) := hc.completeSpace_coe
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
ι : Type u_4
inst✝ : DecidableEq ι
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ
hc : IsComplete ↑(iSup V)
this : CompleteSpace ↥(iSup V)
⊢ DirectSum.IsInternal V ↔ (iSup V)ᗮ = ⊥
state_after: no goals
tactic: simp only [DirectSum.isInternal_submodule_iff_independent_and_iSup_eq_top, hV.independent,
    true_and_iff, Submodule.orthogonal_eq_bot_iff]
Theorem: Multiset.Nodup.toFinset_inj
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t l l' : Multiset α
hl : l.Nodup
hl' : l'.Nodup
h : l.toFinset = l'.toFinset
⊢ l = l'
state_after: no goals
tactic: simpa [← toFinset_eq hl, ← toFinset_eq hl'] using h
Theorem: Finmap.union_comm_of_disjoint
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
⊢ ⟦s₁⟧.Disjoint ⟦s₂⟧ → ⟦s₁⟧ ∪ ⟦s₂⟧ = ⟦s₂⟧ ∪ ⟦s₁⟧
state_after: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ⟦s₁⟧.Disjoint ⟦s₂⟧
⊢ ⟦s₁⟧ ∪ ⟦s₂⟧ = ⟦s₂⟧ ∪ ⟦s₁⟧
tactic: intro h
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ : Finmap β
s₁ s₂ : AList β
h : ⟦s₁⟧.Disjoint ⟦s₂⟧
⊢ ⟦s₁⟧ ∪ ⟦s₂⟧ = ⟦s₂⟧ ∪ ⟦s₁⟧
state_after: no goals
tactic: simp only [AList.toFinmap_eq, union_toFinmap, AList.union_comm_of_disjoint h]
Theorem: Filter.map_iInf_eq
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l : Filter α
f : ι → Filter α
m : α → β
hf : Directed (fun x x_1 => x ≥ x_1) f
inst✝ : Nonempty ι
s : Set β
hs : m ⁻¹' s ∈ iInf f
i : ι
hi : m ⁻¹' s ∈ f i
⊢ map m (f i) ≤ 𝓟 s
state_after: no goals
tactic: simpa only [le_principal_iff, mem_map]
Theorem: PEquiv.toMatrix_symm
File: Mathlib/Data/Matrix/PEquiv.lean

Proof steps:
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
⊢ f.symm.toMatrix = f.toMatrixᵀ
state_after: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
j✝ : m
⊢ f.symm.toMatrix i✝ j✝ = f.toMatrixᵀ i✝ j✝
tactic: ext
state_before: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
j✝ : m
⊢ f.symm.toMatrix i✝ j✝ = f.toMatrixᵀ i✝ j✝
state_after: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
j✝ : m
⊢ (if i✝ ∈ f j✝ then 1 else 0) = of (fun x y => if x ∈ f y then 1 else 0) i✝ j✝
tactic: simp only [transpose, mem_iff_mem f, toMatrix_apply]
state_before: case a
k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : One α
f : m ≃. n
i✝ : n
j✝ : m
⊢ (if i✝ ∈ f j✝ then 1 else 0) = of (fun x y => if x ∈ f y then 1 else 0) i✝ j✝
state_after: no goals
tactic: congr
Theorem: SimpleGraph.Walk.take_spec
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
⊢ (p.takeUntil u h).append (p.dropUntil u h) = p
state_after: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝¹ v✝ w✝ x y : V
inst✝ : DecidableEq V
u v w u✝ : V
h : u ∈ nil.support
⊢ (nil.takeUntil u h).append (nil.dropUntil u h) = nil

case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝¹ v✝¹ w✝¹ x y : V
inst✝ : DecidableEq V
u v w u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
p_ih✝ : ∀ (h : u ∈ p✝.support), (p✝.takeUntil u h).append (p✝.dropUntil u h) = p✝
h : u ∈ (cons h✝ p✝).support
⊢ ((cons h✝ p✝).takeUntil u h).append ((cons h✝ p✝).dropUntil u h) = cons h✝ p✝
tactic: induction p
Theorem: CategoryTheory.GradedObject.single_map_singleObjApplyIso_hom
File: Mathlib/CategoryTheory/GradedObject/Single.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_2} C
inst✝¹ : HasInitial C
inst✝ : DecidableEq J
j : J
X Y : C
f : X ⟶ Y
⊢ (single j).map f j ≫ (singleObjApplyIso j Y).hom = (singleObjApplyIso j X).hom ≫ f
state_after: no goals
tactic: apply single_map_singleObjApplyIsoOfEq_hom
Theorem: UpperSet.coe_iSup₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ ↑(⨆ i, ⨆ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)
state_after: no goals
tactic: simp_rw [coe_iSup]
Theorem: intervalIntegral.integral_mul_deriv_eq_deriv_mul_of_hasDeriv_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝³ : CompleteSpace E
f f' : ℝ → E
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra ℝ A
inst✝ : CompleteSpace A
u v u' v' : ℝ → A
hu : ContinuousOn u [[a, b]]
hv : ContinuousOn v [[a, b]]
huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt u (u' x) (Ioi x) x
hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt v (v' x) (Ioi x) x
hu' : IntervalIntegrable u' volume a b
hv' : IntervalIntegrable v' volume a b
⊢ ∫ (x : ℝ) in a..b, u x * v' x = u b * v b - u a * v a - ∫ (x : ℝ) in a..b, u' x * v x
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝³ : CompleteSpace E
f f' : ℝ → E
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra ℝ A
inst✝ : CompleteSpace A
u v u' v' : ℝ → A
hu : ContinuousOn u [[a, b]]
hv : ContinuousOn v [[a, b]]
huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt u (u' x) (Ioi x) x
hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt v (v' x) (Ioi x) x
hu' : IntervalIntegrable u' volume a b
hv' : IntervalIntegrable v' volume a b
⊢ ∫ (x : ℝ) in a..b, u x * v' x = ∫ (x : ℝ) in a..b, u' x * v x + u x * v' x - u' x * v x

case hf
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝³ : CompleteSpace E
f f' : ℝ → E
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra ℝ A
inst✝ : CompleteSpace A
u v u' v' : ℝ → A
hu : ContinuousOn u [[a, b]]
hv : ContinuousOn v [[a, b]]
huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt u (u' x) (Ioi x) x
hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt v (v' x) (Ioi x) x
hu' : IntervalIntegrable u' volume a b
hv' : IntervalIntegrable v' volume a b
⊢ IntervalIntegrable (fun x => u' x * v x + u x * v' x) volume a b

case hg
ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
a b : ℝ
inst✝³ : CompleteSpace E
f f' : ℝ → E
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra ℝ A
inst✝ : CompleteSpace A
u v u' v' : ℝ → A
hu : ContinuousOn u [[a, b]]
hv : ContinuousOn v [[a, b]]
huu' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt u (u' x) (Ioi x) x
hvv' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt v (v' x) (Ioi x) x
hu' : IntervalIntegrable u' volume a b
hv' : IntervalIntegrable v' volume a b
⊢ IntervalIntegrable (fun x => u' x * v x) volume a b
tactic: rw [← integral_deriv_mul_eq_sub_of_hasDeriv_right hu hv huu' hvv' hu' hv', ← integral_sub]
Theorem: Equiv.symm_apply_eq
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
e : α ≃ β
x : β
y : α
H : e.symm x = y
⊢ x = e y
state_after: no goals
tactic: simp [H.symm]
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Sort u_2
e : α ≃ β
x : β
y : α
H : x = e y
⊢ e.symm x = y
state_after: no goals
tactic: simp [H]