name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Hyperreal.archimedeanClassMk_omega_neg._simp_1 | Mathlib.Analysis.Real.Hyperreal | (ArchimedeanClass.mk Hyperreal.omega < 0) = True | false |
CategoryTheory.Sieve.mk | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(arrows : CategoryTheory.Presieve X) →
(∀ {Y Z : C} {f : Y ⟶ X}, arrows f → ∀ (g : Z ⟶ Y), arrows (CategoryTheory.CategoryStruct.comp g f)) →
CategoryTheory.Sieve X | true |
Filter.Germ.liftPred_coe | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {p : β → Prop} {f : α → β},
Filter.Germ.LiftPred p ↑f ↔ ∀ᶠ (x : α) in l, p (f x) | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_revPerm_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
Multiset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : AddCommMonoid M] {s : Multiset M} (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s ≠ ∅ → (∀ a ∈ s, p a) → p s.sum | true |
StandardEtalePair.lift._proof_3 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
RingHomClass (Polynomial (Polynomial R) →ₐ[R] S) (Polynomial (Polynomial R)) S | false |
Lean.Server.References.ParentDecl.selectionRange | Lean.Server.References | Lean.Server.References.ParentDecl → Lean.Lsp.Range | true |
IntCast.recOn | Init.Data.Int.Basic | {R : Type u} →
{motive : IntCast R → Sort u_1} → (t : IntCast R) → ((intCast : ℤ → R) → motive { intCast := intCast }) → motive t | false |
CategoryTheory.Limits.Cocone.extendId._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cocone F)
(j : J),
(s.extend (CategoryTheory.CategoryStruct.id s.pt)).ι.app j =
CategoryTheory.CategoryStruct.comp (s.ι.app ... | false |
Aesop.PhaseName.safe.sizeOf_spec | Aesop.Rule.Name | sizeOf Aesop.PhaseName.safe = 1 | true |
MeasurableSpace.separatesPoints_of_measurableSingletonClass | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α], MeasurableSpace.SeparatesPoints α | true |
IO.FS.Stream.noConfusionType | Init.System.IO | Sort u → IO.FS.Stream → IO.FS.Stream → Sort u | false |
Lean.Lsp.instToJsonDeleteFile | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.DeleteFile | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.edgeDensity_star_not_uniform._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} {hU : U ∈ P.parts} {hV : V ∈ P.parts},
U ≠ V →
|↑(G.edgeDensity ((SzemerediRegularity.star hP G ε hU V).biUnion id)
... | false |
_private.Mathlib.Algebra.Polynomial.Identities.0.Polynomial.poly_binom_aux3 | Mathlib.Algebra.Polynomial.Identities | ∀ {R : Type u} [inst : CommRing R] (f : Polynomial R) (x y : R),
Polynomial.eval (x + y) f =
((f.sum fun e a => a * x ^ e) + f.sum fun e a => a * ↑e * x ^ (e - 1) * y) +
f.sum fun e a => a * ↑(Polynomial.polyBinomAux1✝ x y e a) * y ^ 2 | true |
_private.Aesop.Index.RulePattern.0.Aesop.RulePatternIndex.getSingle.match_1 | Aesop.Index.RulePattern | (motive : Option Aesop.Substitution → Sort u_1) →
(__discr : Option Aesop.Substitution) →
((subst : Aesop.Substitution) → motive (some subst)) → ((x : Option Aesop.Substitution) → motive x) → motive __discr | false |
CategoryTheory.Bicategory.LeftAdjoint.noConfusion | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {P : Sort u_1} →
{B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : B} →
{right : b ⟶ a} →
{t : CategoryTheory.Bicategory.LeftAdjoint right} →
{B' : Type u} →
{inst' : CategoryTheory.Bicategory B'} →
{a' b' : B'} →
{righ... | false |
CategoryTheory.NatIso.ofComponents'_inv_app | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) ... | true |
LieSubmodule.instLieRingModuleSubtypeMem | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [inst_4 : LieRingModule L M] → (N : LieSubmodule R L M) → LieRingModule L ↥N | true |
LieAlgebra.IsKilling.lieIdealOrderIso._proof_2 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] (H : LieSubalgebra K L) [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieAlgebra.IsKilling K L] [inst_7 : LieModule.IsTriangularizable K (↥H) L]
(q : ↥(LieAlgebra.IsKi... | false |
Std.ExtHashMap.getKey.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β) (e_m : m = m_1) (a a_1 : α) (e_a : a = a_1) (h : a ∈ m), m.getKey a h = m_1.getKey a_1 ⋯ | true |
IsIsometricVAdd | Mathlib.Topology.MetricSpace.IsometricSMul | (M : Type u) → (X : Type w) → [PseudoEMetricSpace X] → [VAdd M X] → Prop | true |
CategoryTheory.sectionsFunctorNatIsoCoyoneda._proof_1 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Type (max u_2 u_3)) [inst_1 : Unique X]
{X_1 Y : CategoryTheory.Functor C (Type (max u_2 u_3))} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.sectionsFunctor C).map f)
((fun F => (F.sectionsEquivHom X).toIso) Y).h... | false |
groupHomology.H2π_comp_map | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.H2π A) (groupHomology.map f φ 2) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapCycles₂ f φ) ... | true |
Std.IterM.TerminationMeasures.Productive.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} → {it it' : Std.IterM m β} → { it := it } = { it := it' } → (it ≍ it' → P) → P | false |
_private.Mathlib.CategoryTheory.Localization.CalculusOfFractions.0.CategoryTheory.MorphismProperty.LeftFraction.map_compatibility._simp_1_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | false |
Complex.le_def | Mathlib.Analysis.Complex.Order | ∀ {z w : ℂ}, z ≤ w ↔ z.re ≤ w.re ∧ z.im = w.im | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_9 | Lean.Compiler.NameMangling | ∀ (s : String) (p : s.Pos) (res : Lean.Name) (h : ¬p = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x =>
PSigma.casesOn ... | false |
Std.Internal.List.getKey_minKey!_eq_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {he : Std.Internal.List.containsKey (Std.Internal.List.minKey! l) l = true},
Std.Internal.List.getKey (Std.Internal.... | true |
ComplexShape.instAssociative | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_7} [inst : AddMonoid I] (c : ComplexShape I) [inst_1 : c.TensorSigns], c.Associative c c c c c | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_546 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w [g (g a)] 1) <
(List.filter (fun x ... | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.«_aux_Mathlib_CategoryTheory_Monoidal_Action_Basic___macroRules_CategoryTheory_MonoidalCategory_MonoidalLeftAction_termλₗ[_]_1» | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.Macro | false |
ProbabilityTheory.IdentDistrib.symm | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ProbabilityTheory.IdentDistrib g f ν μ | true |
CategoryTheory.Limits.factorThruKernelSubobject.congr_simp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f] {W : C} (h h_1 : W ⟶ X) (e_h : h = h_1)
(w : CategoryTheory.CategoryStruct.comp h f = 0),
CategoryTheory.Limits.factorThruKernelSubobject ... | true |
Submodule.inclusion.eq_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p p' : Submodule R M} (h : p ≤ p'), Submodule.inclusion h = LinearMap.codRestrict p' p.subtype ⋯ | true |
Equiv.mul | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Mul β] → Mul α | true |
DFinsupp.comapDomain'._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_3} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' : ι → κ},
Function.LeftInverse h' h →
∀ (f : Π₀ (i : ι), β i) (s : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }) (x : κ),
x ∈ Multiset.map h' ↑s ∨ f (h x) = 0 | false |
Equiv.commRing._proof_8 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (n : ℤ) (x : α), e (e.symm (n • e x)) = n • e x | false |
Std.DHashMap.Raw.toList_toArray | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α],
m.WF → m.toArray.toList = m.toList | true |
Batteries.PairingHeapImp.Heap.WF.rec | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool}
{motive : (a : Batteries.PairingHeapImp.Heap α) → Batteries.PairingHeapImp.Heap.WF le a → Prop},
motive Batteries.PairingHeapImp.Heap.nil ⋯ →
(∀ {a : α} {c : Batteries.PairingHeapImp.Heap α} (h : Batteries.PairingHeapImp.Heap.NodeWF le a c),
motive (Batteries.Pairing... | false |
Nat.log_of_lt | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, n < b → Nat.log b n = 0 | true |
CommRing.Pic.instAddCommGroupAsModule._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) [inst : CommRing R], Small.{u_1, u_1 + 1} (CategoryTheory.Skeleton (SemimoduleCat R))ˣ | false |
instPartialOrderEReal._proof_5 | Mathlib.Data.EReal.Basic | ∀ (a : EReal), a ≤ a | false |
Part.sdiff_get_eq | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : Part α) (hab : (a \ b).Dom), (a \ b).get hab = a.get ⋯ \ b.get ⋯ | true |
IsPurelyInseparable.finSepDegree_eq_one | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [IsPurelyInseparable F E],
Field.finSepDegree F E = 1 | true |
Std.DTreeMap.Internal.Impl.maxKey?_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insert! k v t).maxKey? =
some (t.maxKey?.elim k fun k' => if (compare k' k).isLE = true then k else k') | true |
SimpleGraph.Walk.length | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → ℕ | true |
_private.Lean.Syntax.0.Lean.Syntax.asNode._proof_1 | Lean.Syntax | Lean.IsNode (Lean.Syntax.node Lean.SourceInfo.none Lean.nullKind #[]) | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Iic_sub._proof_1_13 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} (a : Fin n), ↑a + 1 ≤ n → ↑a + 1 < n + 1 | false |
Polynomial.Splits.zero._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.Splits 0 = True | false |
Nat.dfold_add._proof_8 | Init.Data.Nat.Fold | ∀ {n m : ℕ}, ∀ i < n + m, i ≤ n + m | false |
PrimeMultiset.coeNat_prime | Mathlib.Data.PNat.Factors | ∀ (v : PrimeMultiset), ∀ p ∈ v.toNatMultiset, Nat.Prime p | true |
Std.DTreeMap.Raw.getKeyD_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k fallback : α}, k ∉ t₁ → (t₁ ∪ t₂).getKeyD k fallback = t₂.getKeyD k fallback | true |
Asymptotics.isTheta_completion_left | Mathlib.Analysis.Asymptotics.Completion | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F] {f : α → E}
{g : α → F} {l : Filter α}, (fun x => ↑(g x)) =Θ[l] f ↔ g =Θ[l] f | true |
Vector.back_eq_getElem | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type u_1} [inst : NeZero n] {xs : Vector α n}, xs.back = xs[n - 1] | true |
CategoryTheory.ObjectProperty.instAbelianFullSubcategoryOfContainsZeroOfIsClosedUnderKernelsOfIsClosedUnderCokernelsOfIsClosedUnderFiniteProducts._proof_3 | Mathlib.CategoryTheory.Abelian.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Abelian C] [P.IsClosedUnderCokernels], CategoryTheory.Limits.HasCokernels P.FullSubcategory | false |
CategoryTheory.Functor.FullyFaithful.id._proof_1 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C}
(f : (CategoryTheory.Functor.id C).obj X ⟶ (CategoryTheory.Functor.id C).obj Y),
(CategoryTheory.Functor.id C).map f = f | false |
Vector.insertIdx_eraseIdx_of_le | Init.Data.Vector.InsertIdx | ∀ {α : Type u} {a : α} {n i j : ℕ} {xs : Vector α n} (w₁ : i < n) (w₂ : j ≤ n - 1) (h : j ≤ i),
(xs.eraseIdx i w₁).insertIdx j a w₂ = Vector.cast ⋯ ((xs.insertIdx j a ⋯).eraseIdx (i + 1) ⋯) | true |
AddHom.inverse._proof_2 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N) (g : N → M) (x y : N),
g (f (g x) + f (g y)) = g (f (g x + g y)) | false |
ENat.lift_coe | Mathlib.Data.ENat.Basic | ∀ (n : ℕ), (↑n).lift ⋯ = n | true |
Lean.Elab.expandOptNamedPrio | Lean.Elab.Util | Lean.Syntax → Lean.MacroM ℕ | true |
_private.Lean.Environment.0.Lean.Environment.instTypeNameRealizeConstResult | Lean.Environment | TypeName Lean.Environment.RealizeConstResult✝ | true |
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.ceil_intCast._simp_1_2 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {m : ℤ} {n : ℕ}, (m.toNat ≤ n) = (m ≤ ↑n) | false |
ContinuousConstVAdd.toMeasurableConstVAdd | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {M : Type u_7} {α : Type u_8} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α]
[inst_3 : VAdd M α] [ContinuousConstVAdd M α], MeasurableConstVAdd M α | true |
_private.Qq.Match.0.Qq._aux_Qq_Match___macroRules_Lean_Parser_Term_doMatch_1.match_5 | Qq.Match | (motive : Array (Lean.TSyntax `term) × Lean.TSyntax `Lean.Parser.Term.doSeq → Sort u_1) →
(x : Array (Lean.TSyntax `term) × Lean.TSyntax `Lean.Parser.Term.doSeq) →
((patss : Array (Lean.TSyntax `term)) → (rhss : Lean.TSyntax `Lean.Parser.Term.doSeq) → motive (patss, rhss)) →
motive x | false |
Finset.neg_mem_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α} {a : α}, a ∈ s → -a ∈ -s | true |
Filter.IsBoundedUnder.sup | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] {f : Filter β} {u v : β → α},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v → Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => u a ⊔ v a | true |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.SparseCasesOnKey.isPrivate | Lean.Meta.Constructions.SparseCasesOn | Lean.Meta.SparseCasesOnKey✝ → Bool | true |
Filter.HasBasis.inv | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : InvolutiveInv α] {f : Filter α} {ι : Sort u_7} {p : ι → Prop} {s : ι → Set α},
f.HasBasis p s → f⁻¹.HasBasis p fun i => (s i)⁻¹ | true |
Finset.add_univ_of_zero_mem | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α} [inst_2 : Fintype α],
0 ∈ s → s + Finset.univ = Finset.univ | true |
ContinuousOpenMap.casesOn | Mathlib.Topology.Hom.Open | {α : Type u_6} →
{β : Type u_7} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{motive : (α →CO β) → Sort u} →
(t : α →CO β) →
((toContinuousMap : C(α, β)) →
(map_open' : IsOpenMap toContinuousMap.toFun) →
motive { toContinuous... | false |
mem_balancedHull_iff | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] {s : Set E} {x : E},
x ∈ balancedHull 𝕜 s ↔ ∃ r, ‖r‖ ≤ 1 ∧ x ∈ r • s | true |
IsValuativeTopology.hasBasis_nhds | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R]
(x : R), (nhds x).HasBasis (fun x => True) fun γ => {z | (ValuativeRel.valuation R) (z - x) < ↑γ} | true |
UniqueFactorizationMonoid.associated_iff_normalizedFactors_eq_normalizedFactors | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : UniqueFactorizationMonoid α]
{x y : α},
x ≠ 0 →
y ≠ 0 →
(Associated x y ↔ UniqueFactorizationMonoid.normalizedFactors x = UniqueFactorizationMonoid.normalizedFactors y) | true |
Matroid.cRk_map_image | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} (M : Matroid α) (hf : Set.InjOn f M.E) (X : Set α),
autoParam (X ⊆ M.E) Matroid.cRk_map_image._auto_1 → (M.map f hf).cRk (f '' X) = M.cRk X | true |
Std.Internal.Parsec.ByteArray.octDigit | Std.Internal.Parsec.ByteArray | Std.Internal.Parsec.ByteArray.Parser Char | true |
Computation.recOn | Mathlib.Data.Seq.Computation | {α : Type u} →
{motive : Computation α → Sort v} →
(s : Computation α) → ((a : α) → motive (Computation.pure a)) → ((s : Computation α) → motive s.think) → motive s | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.toMonoType.visitApp._sparseCasesOn_8 | Lean.Compiler.LCNF.MonoTypes | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min.noConfusion | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{n : ℕ} →
{X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)} →
{P : Sort u_1} →
{k k' : ℕ} →
{hk : k < n} →
{hk' : k' < n} →
{a : (X k hk).fst} →
{a_1 : (X k' hk').fst... | false |
CategoryTheory.Discrete._aux_Mathlib_CategoryTheory_Discrete_Basic___macroRules_CategoryTheory_Discrete_tacticDiscrete_cases_1 | Mathlib.CategoryTheory.Discrete.Basic | Lean.Macro | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.name | Mathlib.Tactic.Linter.FlexibleLinter | Lean.Name → Mathlib.Linter.Flexible.Stained✝ | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_le_half_iff._proof_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (x : α) (s : Stream'.Seq α) (x_1 : α) (s_1 : Stream'.Seq α),
dist (Stream'.Seq.cons x s) (Stream'.Seq.cons x_1 s_1) ≤ 1 / 2 → x_1 = x | false |
norm_inner_eq_norm_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E}, x ≠ 0 → y ≠ 0 → (‖inner 𝕜 x y‖ = ‖x‖ * ‖y‖ ↔ ∃ r, r ≠ 0 ∧ y = r • x) | true |
CategoryTheory.Functor.LeibnizAdjunction.adj_unit_app_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃))
(G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)) ... | true |
autAdjoinRootXPowSubCEquiv.eq_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ} (hζ : (primitiveRoots n K).Nonempty) {a : K}
(H : Irreducible (Polynomial.X ^ n - Polynomial.C a)) [inst_1 : NeZero n],
autAdjoinRootXPowSubCEquiv hζ H =
{ toFun := (↑(autAdjoinRootXPowSubC n a)).toFun, invFun := AdjoinRootXPowSubCEquivToRootsOfUnity hζ H,
left_inv ... | true |
Char.val_ofOrdinal._proof_2 | Init.Data.Char.Ordinal | ∀ {f : Fin Char.numCodePoints}, ↑f + Char.numSurrogates < UInt32.size | false |
Polynomial.hasseDeriv_apply_one | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {R : Type u_1} [inst : Semiring R] (k : ℕ), 0 < k → (Polynomial.hasseDeriv k) 1 = 0 | true |
Std.ExtDTreeMap.minKey?_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km : α}, t.minKey? = some km → km ∈ t | true |
Finset.coe_inj | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, ↑s₁ = ↑s₂ ↔ s₁ = s₂ | true |
legendreSym.quadratic_reciprocity | Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity | ∀ {p q : ℕ} [inst : Fact (Nat.Prime p)] [inst_1 : Fact (Nat.Prime q)],
p ≠ 2 → q ≠ 2 → p ≠ q → legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2)) | true |
Finset.op_vadd_finset_vadd_eq_vadd_vadd_finset | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq β] [inst_1 : DecidableEq γ] [inst_2 : VAdd αᵃᵒᵖ β]
[inst_3 : VAdd β γ] [inst_4 : VAdd α γ] (a : α) (s : Finset β) (t : Finset γ),
(∀ (a : α) (b : β) (c : γ), (AddOpposite.op a +ᵥ b) +ᵥ c = b +ᵥ a +ᵥ c) → (AddOpposite.op a +ᵥ s) +ᵥ t = s +ᵥ a +ᵥ t | true |
_private.Mathlib.Analysis.Convex.Function.0.neg_strictConvexOn_iff._simp_1_2 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, (a + -b < c) = (a < c + b) | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.span_singleton_mul_eq_span_singleton_mul._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {x y : R} {I J : Ideal R},
(Ideal.span {x} * I ≤ Ideal.span {y} * J) = ∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ | false |
Real.range_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | Set.range Real.arctan = Set.Ioo (-(Real.pi / 2)) (Real.pi / 2) | true |
Lean.Elab.Term.elabCoeSortNotation._regBuiltin.Lean.Elab.Term.elabCoeSortNotation.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.CommRing.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof → Sort u} (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof)
(F_1 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.CommRing.EqCnstrProof) → ... | true |
AddMonoidHom.transfer_def | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} {A : Type u_2} [inst_1 : AddCommGroup A] (ϕ : ↥H →+ A)
(T : H.LeftTransversal) [inst_2 : H.FiniteIndex] (g : G),
ϕ.transfer g = AddSubgroup.leftTransversals.diff ϕ T (g +ᵥ T) | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Pointwise.0.AffineSubspace.pointwise_vadd_top._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Pointwise | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = y) = (x = -g +ᵥ y) | false |
Std.HashMap.getKey?_union | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, (m₁ ∪ m₂).getKey? k = (m₂.getKey? k).or (m₁.getKey? k) | true |
WithTop.continuousOn_untopD | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι] (d : ι),
ContinuousOn (WithTop.untopD d) {a | a ≠ ⊤} | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.