name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
SkewMonoidAlgebra.ctorIdx | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} → {G : Type u_2} → {inst : Zero k} → SkewMonoidAlgebra k G → ℕ | false |
IntermediateField.finInsepDegree_bot | Mathlib.FieldTheory.SeparableClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E], Field.finInsepDegree F ↥⊥ = 1 | true |
Fintype.ofMultiset._proof_1 | Mathlib.Data.Fintype.OfMap | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Multiset α), (∀ (x : α), x ∈ s) → ∀ (x : α), x ∈ s.toFinset | false |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.TaggedState.ctorIdx | Lean.Widget.TaggedText | Lean.Widget.TaggedText.TaggedState✝ → ℕ | false |
CategoryTheory.CategoryOfElements.CreatesLimitsAux.isLimit._proof_2 | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {A : CategoryTheory.Functor C (Type u_5)} {I : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} I] [inst_2 : Small.{u_5, u_3} I]
(F : CategoryTheory.Functor I A.Elements) [inst_3 : CategoryTheory.Limits.HasLimitsOfShape I C]
[inst_4 : CategoryTheory.Limits.PreservesLimitsOfShape I A] (s : CategoryTheory.Limits.Cone F)
(m : s.pt ⟶ (CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone F).pt),
(∀ (j : I),
CategoryTheory.CategoryStruct.comp m ((CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone F).π.app j) =
s.π.app j) →
m =
⟨CategoryTheory.Limits.limit.lift (F.comp (CategoryTheory.CategoryOfElements.π A))
((CategoryTheory.CategoryOfElements.π A).mapCone s),
⋯⟩ | false |
Quiver.SingleObj.toPrefunctor_symm_apply | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {β : Type u_2} (f : Quiver.SingleObj α ⥤q Quiver.SingleObj β) (a : α),
Quiver.SingleObj.toPrefunctor.symm f a = f.map (Quiver.SingleObj.toHom a) | true |
instNegColex | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : Neg α] → Neg (Colex α) | true |
LinearOrderedAddCommGroupWithTop.sub_left_inj_of_ne_top._simp_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α] {a b c : α}, a ≠ ⊤ → (b - a = c - a) = (b = c) | false |
_private.Init.Data.Range.Polymorphic.SInt.0.Int64.instUpwardEnumerable_eq._simp_1_1 | Init.Data.Range.Polymorphic.SInt | ∀ {a b : Int64}, (a = b) = (a.toBitVec = b.toBitVec) | false |
VAdd.recOn | Mathlib.Algebra.Notation.Defs | {G : Type u} →
{P : Type v} →
{motive : VAdd G P → Sort u_1} → (t : VAdd G P) → ((vadd : G → P → P) → motive { vadd := vadd }) → motive t | false |
AddSemigrp.coe_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y Z : AddSemigrp} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
Multiset.gcd | Mathlib.Algebra.GCDMonoid.Multiset | {α : Type u_1} → [inst : CommMonoidWithZero α] → [NormalizedGCDMonoid α] → Multiset α → α | true |
Lean.Lsp.DiagnosticCode.string.sizeOf_spec | Lean.Data.Lsp.Diagnostics | ∀ (s : String), sizeOf (Lean.Lsp.DiagnosticCode.string s) = 1 + sizeOf s | true |
Subring.unop_toSubsemiring | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] (S : Subring Rᵐᵒᵖ), S.unop.toSubsemiring = S.unop | true |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite | Mathlib.CategoryTheory.Sites.CartesianClosed | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u_2) →
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] →
[CategoryTheory.HasSheafify J A] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory A] →
[CategoryTheory.MonoidalClosed (CategoryTheory.Functor Cᵒᵖ A)] →
CategoryTheory.MonoidalClosed (CategoryTheory.Sheaf J A) | true |
Lean.Meta.ppGoal | Lean.Meta.PPGoal | Lean.MVarId → Lean.MetaM Std.Format | true |
AddSubgroup.quotientEquivProdOfLE'._proof_4 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s t : AddSubgroup α} (h_le : s ≤ t) (f : α ⧸ t → α)
(hf : Function.RightInverse f QuotientAddGroup.mk),
Function.LeftInverse (fun a => Quotient.map' (fun b => f a.1 + ↑b) ⋯ a.2) fun a =>
(Quotient.map' id ⋯ a, Quotient.map' (fun g => ⟨-f (Quotient.mk'' g) + g, ⋯⟩) ⋯ a) | false |
Frm.Hom.rec | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → (t : X.Hom Y) → motive t | false |
MeasureTheory.hittingAfter_anti | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] (u : ι → Ω → β) (n : ι),
Antitone fun x => MeasureTheory.hittingAfter u x n | true |
Lean.Elab.Term.ExtractMonadResult.noConfusionType | Lean.Elab.Do.Legacy | Sort u → Lean.Elab.Term.ExtractMonadResult → Lean.Elab.Term.ExtractMonadResult → Sort u | false |
ScottContinuousOn.prodMk | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{D : Set (Set α)} {f : α → β} {g : α → γ},
(∀ (a b : α), a ≤ b → {a, b} ∈ D) →
ScottContinuousOn D f → ScottContinuousOn D g → ScottContinuousOn D fun x => (f x, g x) | true |
Filter.coprodᵢ_bot' | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2}, Filter.coprodᵢ ⊥ = ⊥ | true |
subalgebraEquivIntermediateField._proof_3 | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : Algebra.IsAlgebraic K L] {a b : Subalgebra K L},
{ toFun := fun S => S.toIntermediateField ⋯, invFun := fun S => S.toSubalgebra, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := fun S => S.toIntermediateField ⋯, invFun := fun S => S.toSubalgebra, left_inv := ⋯, right_inv := ⋯ }
b ↔
{ toFun := fun S => S.toIntermediateField ⋯, invFun := fun S => S.toSubalgebra, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := fun S => S.toIntermediateField ⋯, invFun := fun S => S.toSubalgebra, left_inv := ⋯, right_inv := ⋯ } b | false |
CategoryTheory.MonoidalCategory._aux_Mathlib_CategoryTheory_Monoidal_Category___unexpand_CategoryTheory_MonoidalCategoryStruct_tensorObj_1 | Mathlib.CategoryTheory.Monoidal.Category | Lean.PrettyPrinter.Unexpander | false |
WithVal.equivWithVal_apply | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {Γ'₀ : Type u_3}
[inst_2 : LinearOrderedCommGroupWithZero Γ'₀] (v : Valuation R Γ₀) (w : Valuation R Γ'₀) {x : WithVal v},
(WithVal.congr v w (RingEquiv.refl R)) x = (WithVal.equiv w).symm ((WithVal.equiv v) x) | true |
Finsupp.update_eq_add_single | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddZeroClass M] {f : ι →₀ M} {a : ι},
f a = 0 → ∀ (b : M), f.update a b = f + fun₀ | a => b | true |
Lean.ToLevel.casesOn | Lean.ToLevel | {motive : Lean.ToLevel → Sort u_1} →
(t : Lean.ToLevel) →
((toLevel : Lean.Level) → (univ : ∀ (x : Sort u), True) → motive { toLevel := toLevel }) → motive t | false |
CompHausLike.productIsLimit._proof_7 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) [inst : CompHausLike.HasProp P (↑X.toTop × ↑Y.toTop)]
(x : CategoryTheory.Limits.BinaryFan X Y) (x_1 : x.pt ⟶ CompHausLike.of P (↑X.toTop × ↑Y.toTop)),
CategoryTheory.CategoryStruct.comp x_1 (CompHausLike.ofHom P { toFun := Prod.fst, continuous_toFun := ⋯ }) = x.fst →
CategoryTheory.CategoryStruct.comp x_1 (CompHausLike.ofHom P { toFun := Prod.snd, continuous_toFun := ⋯ }) = x.snd →
x_1 =
CompHausLike.ofHom P
{
toFun := fun x_2 =>
((CategoryTheory.ConcreteCategory.hom x.fst) x_2, (CategoryTheory.ConcreteCategory.hom x.snd) x_2),
continuous_toFun := ⋯ } | false |
_private.Lean.Elab.Tactic.Omega.Core.0.Lean.Elab.Tactic.Omega.Problem.fourierMotzkinSelect.match_1 | Lean.Elab.Tactic.Omega.Core | (motive : Option Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData → Sort u_1) →
(x : Option Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData) →
(Unit → motive none) → ((a : Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData) → motive (some a)) → motive x | false |
Lean.Meta.Grind.Arith.CommRing.Semiring.type | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.Semiring → Lean.Expr | true |
UInt8.left_eq_add._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = a + b) = (b = 0) | false |
ProbabilityTheory.Kernel.iIndepSets_zero_right | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {π : ι → Set (Set Ω)}, ProbabilityTheory.Kernel.iIndepSets π κ 0 | true |
String.ltb._unary.induct_unfolding | Mathlib.Data.String.Basic | ∀ (motive : (_ : String.Legacy.Iterator) ×' String.Legacy.Iterator → Bool → Prop),
(∀ (s₁ s₂ : String.Legacy.Iterator),
s₂.hasNext = true →
s₁.hasNext = true →
s₁.curr = s₂.curr →
motive ⟨s₁.next, s₂.next⟩ (String.ltb._unary ⟨s₁.next, s₂.next⟩) →
motive ⟨s₁, s₂⟩ (String.ltb._unary ⟨s₁.next, s₂.next⟩)) →
(∀ (s₁ s₂ : String.Legacy.Iterator),
s₂.hasNext = true → s₁.hasNext = true → ¬s₁.curr = s₂.curr → motive ⟨s₁, s₂⟩ (decide (s₁.curr < s₂.curr))) →
(∀ (s₁ s₂ : String.Legacy.Iterator), s₂.hasNext = true → ¬s₁.hasNext = true → motive ⟨s₁, s₂⟩ true) →
(∀ (s₁ s₂ : String.Legacy.Iterator), ¬s₂.hasNext = true → motive ⟨s₁, s₂⟩ false) →
∀ (_x : (_ : String.Legacy.Iterator) ×' String.Legacy.Iterator), motive _x (String.ltb._unary _x) | false |
MeasurableSpace.DynkinSystem.generate_le | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} (d : MeasurableSpace.DynkinSystem α) {s : Set (Set α)},
(∀ t ∈ s, d.Has t) → MeasurableSpace.DynkinSystem.generate s ≤ d | true |
CategoryTheory.Precoverage.instCompleteLattice._proof_1 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {x y : CategoryTheory.Precoverage C},
x.coverings ≤ y.coverings ↔ x.coverings ≤ y.coverings | false |
CategoryTheory.Abelian.Ext.add_comp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α₁ α₂ : CategoryTheory.Abelian.Ext X Y n) {m : ℕ}
(β : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p), (α₁ + α₂).comp β h = α₁.comp β h + α₂.comp β h | true |
Topology.IsOpenEmbedding.recOn | Mathlib.Topology.Defs.Induced | {X : Type u_1} →
{Y : Type u_2} →
[tX : TopologicalSpace X] →
[tY : TopologicalSpace Y] →
{f : X → Y} →
{motive : Topology.IsOpenEmbedding f → Sort u} →
(t : Topology.IsOpenEmbedding f) →
((toIsEmbedding : Topology.IsEmbedding f) → (isOpen_range : IsOpen (Set.range f)) → motive ⋯) → motive t | false |
Lean.TraceResult.success | Lean.Message | Lean.TraceResult | true |
Finset.sum_Ico_succ_sub_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {m n : ℕ} [inst : AddCommGroup M],
m ≤ n → ∑ i ∈ Finset.Ico m (n + 1), f i - f n = ∑ i ∈ Finset.Ico m n, f i | true |
Filter.mem_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {s t : Set α}, s ∈ f ⊓ Filter.principal t ↔ {x | x ∈ t → x ∈ s} ∈ f | true |
_private.Init.Data.List.Sublist.0.List.prefix_concat_iff._simp_1_4 | Init.Data.List.Sublist | ∀ {α : Type u_1} {as bs : List α}, (as.reverse = bs) = (as = bs.reverse) | false |
Unitary.path._proof_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)),
Continuous fun t => selfAdjoint.expUnitary (↑t • Unitary.argSelfAdjoint (v * star u)) * u | false |
Sym2.fromRel._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop}, Symmetric r → ∀ (x x_1 : α), r x x_1 = r x_1 x | false |
Set.preimage_const_sub_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => a - x) ⁻¹' Set.Ico b c = Set.Ioc (a - c) (a - b) | true |
BitVec.toFin_umod | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x % y).toFin = x.toFin % y.toFin | true |
DividedPowers.ofInjective._proof_1 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B) (hJ : DividedPowers J)
(hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {n : ℕ} {x : A},
x ∉ I → (if hx : x ∈ I then ⋯.choose else 0) = 0 | false |
Nat.toList_roo_eq_cons | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, m + 1 < n → (m<...n).toList = (m + 1) :: ((m + 1)<...n).toList | true |
PiTensorProduct.dualDistrib.congr_simp | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι], PiTensorProduct.dualDistrib = PiTensorProduct.dualDistrib | true |
_private.Init.Data.Array.Lemmas.0.Array.mem_flatMap._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xss : Array (Array α)}, (a ∈ xss.flatten) = ∃ xs ∈ xss, a ∈ xs | false |
Lean.Server.FileWorker.handleSignatureHelp | Lean.Server.FileWorker.RequestHandling | Lean.Lsp.SignatureHelpParams → Lean.Server.RequestM (Lean.Server.RequestTask (Option Lean.Lsp.SignatureHelp)) | true |
GroupExtension.Section._sizeOf_inst | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
{inst : Group N} →
{inst_1 : Group E} →
{inst_2 : Group G} → (S : GroupExtension N E G) → [SizeOf N] → [SizeOf E] → [SizeOf G] → SizeOf S.Section | false |
_private.Init.Data.Int.Linear.0.Int.Linear.Poly.combine'.match_3.eq_1 | Init.Data.Int.Linear | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (fuel : ℕ) → motive fuel.succ),
(match 0 with
| 0 => h_1 ()
| fuel.succ => h_2 fuel) =
h_1 () | true |
_private.Mathlib.LinearAlgebra.Matrix.NonsingularInverse.0.Matrix.add_mul_mul_inv_eq_sub._simp_1_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
[inst_3 : Invertible A], A⁻¹ = ⅟A | false |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.finite_of_nat_weight_le._simp_1_5 | Mathlib.Data.Finsupp.Weight | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | false |
ByteArray.validateUTF8 | Init.Data.String.Basic | ByteArray → Bool | true |
_private.Mathlib.LinearAlgebra.Dimension.StrongRankCondition.0.strongRankCondition_iff_forall_zero_lt_finrank.match_1_3 | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u_1} [inst : Semiring R] (motive : (∃ n, Cardinal.aleph0 ≤ Module.rank R (Fin n → R)) → Prop)
(x : ∃ n, Cardinal.aleph0 ≤ Module.rank R (Fin n → R)),
(∀ (n : ℕ) (le : Cardinal.aleph0 ≤ Module.rank R (Fin n → R)), motive ⋯) → motive x | false |
NFA.Path.cons | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} → (t s u : σ) → (a : α) → (x : List α) → t ∈ M.step s a → M.Path t u x → M.Path s u (a :: x) | true |
Finset.attachFin_ssubset_attachFin_iff | Mathlib.Data.Finset.Fin | ∀ {n : ℕ} {s t : Finset ℕ} (hs : ∀ m ∈ s, m < n) (ht : ∀ m ∈ t, m < n), s.attachFin hs ⊂ t.attachFin ht ↔ s ⊂ t | true |
Vector.ofFn_add | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {n m : ℕ} {f : Fin (n + m) → α},
Vector.ofFn f = (Vector.ofFn fun i => f (Fin.castLE ⋯ i)) ++ Vector.ofFn fun i => f (Fin.natAdd n i) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
ContDiffOn.norm_sq | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {G : Type u_4} [inst_2 : NormedAddCommGroup G] [inst_3 : NormedSpace ℝ G] {f : G → E}
{s : Set G} {n : WithTop ℕ∞}, ContDiffOn ℝ n f s → ContDiffOn ℝ n (fun y => ‖f y‖ ^ 2) s | true |
Rat.infinitePlace | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | NumberField.InfinitePlace ℚ | true |
Matroid.isCircuit_iff_forall_ssubset | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C : Set α}, M.IsCircuit C ↔ M.Dep C ∧ ∀ ⦃I : Set α⦄, I ⊂ C → M.Indep I | true |
_private.Init.Data.List.Nat.InsertIdx.0.List.insertIdx_eraseIdx._proof_1_1 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} {i : ℕ} {as : List α} {j : ℕ}, ¬i ≤ j → ¬j ≤ i → False | false |
_private.Mathlib.Topology.Algebra.Module.Cardinality.0.cardinal_eq_of_mem_nhds_zero._simp_1_1 | Mathlib.Topology.Algebra.Module.Cardinality | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (n : ℕ), (a ^ n)⁻¹ = a⁻¹ ^ n | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → J.Cover X → Type (max u v) | true |
SDiff.mk._flat_ctor | Init.Core | {α : Type u} → (α → α → α) → SDiff α | false |
Int.lt_irrefl | Init.Data.Int.Order | ∀ (a : ℤ), ¬a < a | true |
IsQuasiSeparated.of_quasiSeparatedSpace | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] [QuasiSeparatedSpace α] (s : Set α), IsQuasiSeparated s | true |
Submodule.closedComplemented_iff_isClosed_exists_isClosed_isCompl | Mathlib.Analysis.Normed.Module.Complemented | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CompleteSpace E] {p : Subspace 𝕜 E},
Submodule.ClosedComplemented p ↔ IsClosed ↑p ∧ ∃ q, IsClosed ↑q ∧ IsCompl p q | true |
Std.TreeSet.Equiv.diff_congr | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ t₃ t₄ : Std.TreeSet α cmp} [Std.TransCmp cmp],
t₁.Equiv t₃ → t₂.Equiv t₄ → (t₁ \ t₂).Equiv (t₃ \ t₄) | true |
Antitone.neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] [AddRightMono α]
[inst_4 : Preorder β] {f : β → α}, Antitone f → Monotone fun x => -f x | true |
IsStronglyAtomic | Mathlib.Order.Atoms | (α : Type u_5) → [Preorder α] → Prop | true |
Std.Time.Year.Era.casesOn | Std.Time.Date.Unit.Year | {motive : Std.Time.Year.Era → Sort u} →
(t : Std.Time.Year.Era) → motive Std.Time.Year.Era.bce → motive Std.Time.Year.Era.ce → motive t | false |
CategoryTheory.MonoidalCategory.id_whiskerRight | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.id X) Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (x y i : ℕ) (c : Bool), c.toNat ≤ 1 → ¬x % 2 ^ i + (y % 2 ^ i + c.toNat) < 2 ^ i * 2 → False | false |
IsLocalization.ideal_eq_iInf_comap_map_away | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Finset R},
Ideal.span ↑S = ⊤ →
∀ (I : Ideal R),
I = ⨅ f ∈ S, Ideal.comap (algebraMap R (Localization.Away f)) (Ideal.map (algebraMap R (Localization.Away f)) I) | true |
Batteries.RBNode.instDecidableOrderedOfTransCmp | Batteries.Data.RBMap.Lemmas | {α : Type u_1} →
(cmp : α → α → Ordering) → [Std.TransCmp cmp] → (t : Batteries.RBNode α) → Decidable (Batteries.RBNode.Ordered cmp t) | true |
SymAlg.mul_comm | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : AddCommSemigroup α] [inst_2 : One α] [inst_3 : OfNat α 2]
[inst_4 : Invertible 2] (a b : αˢʸᵐ), a * b = b * a | true |
Lean.TraceResult.failure.elim | Lean.Message | {motive : Lean.TraceResult → Sort u} →
(t : Lean.TraceResult) → t.ctorIdx = 1 → motive Lean.TraceResult.failure → motive t | false |
OpenNormalAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | (G : Type u) → [AddGroup G] → [TopologicalSpace G] → Type u | true |
ContinuousInf.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Min L] →
{motive : ContinuousInf L → Sort u} →
((continuous_inf : Continuous fun p => p.1 ⊓ p.2) → motive ⋯) → (t : ContinuousInf L) → motive t | false |
AffineIndependent.smul | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ (k : Type u_1) {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {ι : Type u_4}
{G : Type u_5} [inst_3 : Group G] [inst_4 : DistribMulAction G V] [SMulCommClass G k V] {p : ι → V} {a : G},
AffineIndependent k p → AffineIndependent k (a • p) | true |
Module.End.mulSemiringActionToAlgEquiv_conjAct_surjective | Mathlib.LinearAlgebra.GeneralLinearGroup.AlgEquiv | ∀ {K : Type u_1} {V : Type u_2} [inst : Semifield K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V]
[Module.Projective K V], Function.Surjective (MulSemiringAction.toAlgEquiv K (Module.End K V)) | true |
LinearMap.BilinForm.flip_flip | Mathlib.LinearAlgebra.BilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.BilinForm.flipHom ≪≫ₗ LinearMap.BilinForm.flipHom = LinearEquiv.refl R (LinearMap.BilinForm R M) | true |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_4 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᴹᵒᵖᴹᵒᵖ} (X' : Cᴹᵒᵖᴹᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X')
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map f))
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X')
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj Y))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X')
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj X)))
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.map
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f)) | false |
Tactic.NormNum.evalRealSqrt | Mathlib.Tactic.NormNum.RealSqrt | Mathlib.Meta.NormNum.NormNumExt | true |
LieAlgebra.ExtendScalars.instLieAlgebra._proof_1 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_3) (A : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L], SMulCommClass A A (TensorProduct R A L) | false |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.isNat_natSub.match_1_1 | Mathlib.Tactic.NormNum.Basic | ∀
(motive :
(x x_1 x_2 x_3 x_4 : ℕ) →
Mathlib.Meta.NormNum.IsNat x x_2 → Mathlib.Meta.NormNum.IsNat x_1 x_3 → x_2.sub x_3 = x_4 → Prop)
(x x_1 x_2 x_3 x_4 : ℕ) (x_5 : Mathlib.Meta.NormNum.IsNat x x_2) (x_6 : Mathlib.Meta.NormNum.IsNat x_1 x_3)
(x_7 : x_2.sub x_3 = x_4),
(∀ (n n_1 : ℕ), motive (↑n) (↑n_1) n n_1 (n.sub n_1) ⋯ ⋯ ⋯) → motive x x_1 x_2 x_3 x_4 x_5 x_6 x_7 | false |
_private.Mathlib.Tactic.IrreducibleDef.0.Lean.Elab.Command._aux_Mathlib_Tactic_IrreducibleDef___elabRules_Lean_Elab_Command_command_Irreducible_def_____1.match_3 | Mathlib.Tactic.IrreducibleDef | (motive : Option (Lean.TSyntax `Lean.Parser.Command.unsafe) → Sort u_1) →
(uns : Option (Lean.TSyntax `Lean.Parser.Command.unsafe)) →
((uns : Lean.TSyntax `Lean.Parser.Command.unsafe) → motive (some uns)) →
((x : Option (Lean.TSyntax `Lean.Parser.Command.unsafe)) → motive x) → motive uns | false |
Std.DTreeMap.Const.getKey?_filter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
(Std.DTreeMap.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.DTreeMap.Const.get t x ⋯) | true |
instLieRingAddGroupLieAlgebra | Mathlib.Geometry.Manifold.GroupLieAlgebra | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{G : Type u_4} →
[inst_4 : TopologicalSpace G] →
[inst_5 : ChartedSpace H G] →
[inst_6 : AddGroup G] →
[LieAddGroup I (minSmoothness 𝕜 3) G] → [CompleteSpace E] → LieRing (AddGroupLieAlgebra I G) | true |
LocallyConstant.instSub | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [Sub Y] → Sub (LocallyConstant X Y) | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceNat._proof_1 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (u : ℤ × ℤ) {i j j' : ℕ × ℕ},
↑i.1 + u.1 = ↑j.1 ∧ ↑i.2 + u.2 = ↑j.2 → ↑i.1 + u.1 = ↑j'.1 ∧ ↑i.2 + u.2 = ↑j'.2 → j.1 = j'.1 | false |
Lean.Elab.Do.Context.monadInfo | Lean.Elab.Do.Basic | Lean.Elab.Do.Context → Lean.Elab.Do.MonadInfo | true |
instPartialOrderAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ (G : Type u_1) [inst : AddCommGroup G], instPartialOrderAddGroupCone G = PartialOrder.ofSetLike (AddGroupCone G) G | true |
Interval.coe_inj | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α] {s t : NonemptyInterval α}, ↑s = ↑t ↔ s = t | true |
Matrix.charpoly_fin_two | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] [Nontrivial R] (M : Matrix (Fin 2) (Fin 2) R),
M.charpoly = Polynomial.X ^ 2 - Polynomial.C M.trace * Polynomial.X + Polynomial.C M.det | true |
Matrix.conjTranspose_submatrix | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Star α] (A : Matrix m n α)
(r : l → m) (c : o → n), (A.submatrix r c).conjTranspose = A.conjTranspose.submatrix c r | true |
ofColex_toColex | Mathlib.Order.Lex | ∀ {α : Type u_1} (a : α), ofColex (toColex a) = a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.