name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
mul_lt_mul_of_pos_of_nonneg | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c d : α} [PosMulStrictMono α]
[MulPosMono α], a ≤ b → c < d → 0 < a → 0 ≤ d → a * c < b * d | true |
Algebra.algebraMap_ofSubsemiring_apply | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {C : Type u_4} [inst_1 : SetLike C R] [inst_2 : SubsemiringClass C R] (S : C)
(x : ↥S), (algebraMap (↥S) R) x = ↑x | true |
Matrix.mulVec_single | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : NonUnitalNonAssocSemiring R] (M : Matrix m n R) (j : n) (x : R),
M.mulVec (Pi.single j x) = MulOpposite.op x • M.col j | true |
SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_internal | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {i : ℕ} {p : G.Walk u u},
p.IsCycle → i ≠ 0 → i < p.length → p.toSubgraph.neighborSet (p.getVert i) = {p.getVert (i - 1), p.getVert (i + 1)} | true |
Homeomorph.isClosed_image | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y) {s : Set X},
IsClosed (⇑h '' s) ↔ IsClosed s | true |
Real.taylor_tendsto | Mathlib.Analysis.Calculus.Taylor | ∀ {f : ℝ → ℝ} {x₀ : ℝ} {n : ℕ} {s : Set ℝ},
Convex ℝ s →
x₀ ∈ s →
ContDiffOn ℝ (↑n) f s →
Filter.Tendsto (fun x => (f x - taylorWithinEval f n s x₀ x) / (x - x₀) ^ n) (nhdsWithin x₀ s) (nhds 0) | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLT._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.lt) → α × β | false |
ofDual_max | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] (a b : αᵒᵈ),
OrderDual.ofDual (max a b) = min (OrderDual.ofDual a) (OrderDual.ofDual b) | true |
CochainComplex.ConnectData.homologyIsoPos | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{K : ChainComplex C ℕ} →
{L : CochainComplex C ℕ} →
(h : CochainComplex.ConnectData K L) →
(n : ℕ) →
[NeZero n] →
(m : ℤ) →
... | true |
Polynomial.toLaurent_C_mul_eq | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (r : R) (f : Polynomial R),
Polynomial.toLaurent (Polynomial.C r * f) = LaurentPolynomial.C r * Polynomial.toLaurent f | true |
FreeMagma.toFreeSemigroup_comp_of | Mathlib.Algebra.Free | ∀ {α : Type u}, ⇑FreeMagma.toFreeSemigroup ∘ FreeMagma.of = FreeSemigroup.of | true |
CategoryTheory.MonoOver.pullbackMapSelf._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasPullbacks C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Mono f], CategoryTheory.IsIso (CategoryTheory.MonoOver.mapPullbackAdj f).unit | false |
WeierstrassCurve.Jacobian.add_of_Z_eq_zero_left | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P Q : Fin 3 → R},
W'.Equation P → P 2 = 0 → Q 2 ≠ 0 → W'.add P Q = (P 0 * Q 2) • Q | true |
ZFSet.IsTransitive.sUnion' | Mathlib.SetTheory.ZFC.Ordinal | ∀ {x : ZFSet.{u}}, (∀ y ∈ x, y.IsTransitive) → x.sUnion.IsTransitive | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le' | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) {r r' : ℤ} (hrr' : r + 1 = r')
(hr : r₀ ≤ r) (pq' : κ) {i₀' i₀ : ι}, i₀' = data.i₀ r' pq' ⋯ → i₀ = data.i₀ r pq' ⋯ → i₀' ≤ i₀ | true |
_private.Mathlib.Tactic.FunProp.Elab.0.Mathlib.Meta.FunProp.funPropTac._sparseCasesOn_1 | Mathlib.Tactic.FunProp.Elab | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
PresheafOfModules.free._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Free | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
{F G : CategoryTheory.Functor Cᵒᵖ (Type u_1)} (φ : F ⟶ G) {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((PresheafOfModules.freeObj F).map f)
((ModuleCat.restrictScalars (RingCat.Hom.hom (R.ma... | false |
MeasureTheory.OuterMeasure.measureOf_eq_coe | Mathlib.MeasureTheory.OuterMeasure.Defs | ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α), m.measureOf = ⇑m | true |
CategoryTheory.instAbelianInd._proof_3 | Mathlib.CategoryTheory.Abelian.Indization | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [CategoryTheory.Abelian C],
CategoryTheory.Limits.HasFiniteProducts (CategoryTheory.Ind C) | false |
Real.rpow_lt_one_iff' | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ}, 0 ≤ x → 0 < y → (x ^ y < 1 ↔ x < 1) | true |
FP.Float.casesOn | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
{motive : FP.Float → Sort u} →
(t : FP.Float) →
((a : Bool) → motive (FP.Float.inf a)) →
motive FP.Float.nan →
((a : Bool) → (e : ℤ) → (m : ℕ) → (a_1 : FP.ValidFinite e m) → motive (FP.Float.finite a e m a_1)) → motive t | false |
HomologicalComplex.instPreservesZeroMorphismsHomologyFunctor | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C],
(HomologicalComplex.homologyFunctor C c i).PreservesZeroMorphisms | true |
Std.Rii.iter | Std.Data.Iterators.Producers.Range | {α : Type u_1} → [Std.PRange.Least? α] → Std.Rii α → Std.Iter α | true |
SubsemiringClass.subtype_injective | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : SetLike S R] [hSR : SubsemiringClass S R] (s : S),
Function.Injective ⇑(SubsemiringClass.subtype s) | true |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.highlightTaggedText | Lean.Server.FileWorker.WidgetRequests | {α : Type u_1} →
{β : Type} →
String →
Lean.Widget.TaggedText α →
β →
(α → String) →
(α →
(Lean.Widget.TaggedText α → StateM Lean.Widget.TaggedTextHighlightState✝ (Lean.Widget.TaggedText β)) →
StateM Lean.Widget.TaggedTextHighlightState✝ β) →
... | true |
SheafOfModules.freeHomEquiv_symm_comp | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddC... | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.collectDirectVarsInPattern.go._unsafe_rec | Lean.Meta.IndPredBelow | Lean.Meta.Match.Pattern → Array Lean.FVarId → Array Lean.FVarId | false |
Batteries.RBSet.AlterWF.casesOn | Batteries.Data.RBMap.Basic | {α : Type u_1} →
{cmp : α → α → Ordering} →
{t : Batteries.RBSet α cmp} →
{cut : α → Ordering} →
{f : Option α → Option α} →
{motive : t.AlterWF cut f → Sort u} →
(t_1 : t.AlterWF cut f) →
((wf : Batteries.RBNode.WF cmp (Batteries.RBNode.alter cut f ↑t)) → motive ... | false |
ManyOneDegree.instPartialOrder | Mathlib.Computability.Reduce | PartialOrder ManyOneDegree | true |
CategoryTheory.MonoidalCategory.tensor_left_unitality_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X₁ X₂ : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.... | true |
LatticeCon.mk'._proof_4 | Mathlib.Order.Lattice.Congruence | ∀ {α : Type u_1} [inst : Lattice α] (r : α → α → Prop) [h₁ : Std.Refl r],
(∀ ⦃x y : α⦄, r x y ↔ r (x ⊓ y) (x ⊔ y)) →
(∀ ⦃x y z : α⦄, x ≤ y → y ≤ z → r x y → r y z → r x z) →
(∀ ⦃x y t : α⦄, x ≤ y → r x y → r (x ⊓ t) (y ⊓ t) ∧ r (x ⊔ t) (y ⊔ t)) → Equivalence r | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.isLindelof_of_countable_subcover._simp_1_1 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u} {f : Filter α}, (¬f.NeBot) = (f = ⊥) | false |
Bundle.Pretrivialization.domExtend._proof_9 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
{s : Set B} (e : Bundle.Pretrivialization F fun z => proj ↑z), IsOpen e.baseSet | false |
Set.mem_of_indicator_ne_zero | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] {s : Set α} {f : α → M} {a : α}, s.indicator f a ≠ 0 → a ∈ s | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated.0.CochainComplex.mappingCone.rotateHomotopyEquiv._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ (n : ℤ), n + 1 + -1 = n | false |
_private.Mathlib.Topology.OpenPartialHomeomorph.Basic.0.OpenPartialHomeomorph.toHomeomorphOfSourceEqUnivTargetEqUniv._simp_3 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
ContinuousOn f Set.univ = Continuous f | false |
le_sdiff_right | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], x ≤ y \ x ↔ x = ⊥ | true |
Lean.Server.ServerTask.pure | Lean.Server.ServerTask | {α : Type u_1} → α → Lean.Server.ServerTask α | true |
Multiset.lists | Mathlib.Data.Fintype.List | {α : Type u_1} → Multiset α → Multiset (List α) | true |
ContinuousSqrt | Mathlib.Topology.ContinuousMap.StarOrdered | (R : Type u_1) → [LE R] → [NonUnitalSemiring R] → [TopologicalSpace R] → Type u_1 | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.PolyDerivation.getMultiplier.go.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | (motive : Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u_1) →
(d : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
((p : Lean.Grind.CommRing.Poly) → motive (Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input p)) →
((p : Lean.Grind.CommRing.Poly) →
(k₁ : ℤ) →
(d : Lean.Meta.Gr... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.go_decl_eq._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ}
(_x :
(aig : Std.Sat.AIG α) ×'
(_ : ℕ) ×' (_ : aig.RefVec w) ×' (_ : aig.RefVec w) ×' (_ : ℕ) ×' (_ : ℕ) ×' (_ : aig.RefVec w) ×' aig.RefVec w)
(idx : ℕ) (h1 : idx < _x.1.decls.size)
(h2 :
idx <
(Std.Tactic.BVDecide.BVExpr.bitbl... | false |
EuclideanDomain.xgcd.eq_1 | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [inst : EuclideanDomain R] [inst_1 : DecidableEq R] (x y : R),
EuclideanDomain.xgcd x y = (EuclideanDomain.xgcdAux x 1 0 y 0 1).2 | true |
_private.Mathlib.Analysis.InnerProductSpace.Symmetric.0.LinearMap.IsSymmetric.inner_map_polarization._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
CategoryTheory.Limits.Cone.ofTrident._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_2} {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C]
{F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C}
(X : CategoryTheory.Limits.WalkingParallelFamily J),
(CategoryTheory.Limits.parallelFamily fun j => F.map (CategoryTheory.Limits.WalkingParallelFamily.Hom.li... | false |
Matroid.inter_ground_subset_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X : Set α), X ∩ M.E ⊆ M.closure X | true |
PosPart.posPart | Mathlib.Algebra.Notation | {α : Type u_1} → [self : PosPart α] → α → α | true |
Lean.Meta.Sym.getUInt8Value? | Lean.Meta.Sym.LitValues | Lean.Expr → OptionT Id UInt8 | true |
Set.finite_image_fst_and_snd_iff | Mathlib.Data.Finite.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set (α × β)}, (Prod.fst '' s).Finite ∧ (Prod.snd '' s).Finite ↔ s.Finite | true |
Real.sSup_le | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ} {a : ℝ}, (∀ x ∈ s, x ≤ a) → 0 ≤ a → sSup s ≤ a | true |
Part.coe_none | Mathlib.Data.Part | ∀ {α : Type u_1}, ↑none = Part.none | true |
WithBot.denselyOrdered_set_iff_subsingleton | Mathlib.Order.Interval.Finset.DenselyOrdered | ∀ {X : Type u_1} [inst : LinearOrder X] [LocallyFiniteOrder X] {s : Set (WithBot X)}, DenselyOrdered ↑s ↔ s.Subsingleton | true |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.Precoverage.ZeroHypercover.instSmall.match_3 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (ι : Type (max u_2 u_1)) (Y : ι → C)
(f : (i : ι) → Y i ⟶ S) (motive : (Z : C) → (g : Z ⟶ S) → CategoryTheory.Presieve.ofArrows Y f g → Prop) (Z : C)
(g : Z ⟶ S) (x : CategoryTheory.Presieve.ofArrows Y f g), (∀ (i : ι), motive (Y i) (f i) ⋯) → m... | false |
SSet.ι₁_app_snd_apply | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ {X : SSet} {m : ℕ} (x : X.obj (Opposite.op { len := m })) (k : Fin (m + 1)),
(SSet.ι₁.app (Opposite.op { len := m }) x).2 k = 1 | true |
CategoryTheory.Functor.flip₁₃Functor_obj_obj_obj_obj | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_4} {E : Type u_9} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_4} C₃]
[inst_3 : CategoryTheory.Category.{v_9, u_9} E]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C... | true |
NonUnitalNonAssocRing.mk.noConfusion | Mathlib.Algebra.Ring.Defs | {α : Type u} →
{P : Sort u_1} →
{toAddCommGroup : AddCommGroup α} →
{toMul : Mul α} →
{left_distrib : ∀ (a b c : α), a * (b + c) = a * b + a * c} →
{right_distrib : ∀ (a b c : α), (a + b) * c = a * c + b * c} →
{zero_mul : ∀ (a : α), 0 * a = 0} →
{mul_zero : ∀ (a ... | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists_subset_injOn_image_eq_of_surjOn._simp_1_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
_private.Mathlib.RingTheory.Ideal.Norm.RelNorm.0.Ideal.spanNorm_eq_bot_iff._simp_1_4 | Mathlib.RingTheory.Ideal.Norm.RelNorm | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
Std.IterM.step_filter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] {it : Std.IterM m β} [inst_1 : Monad m]
[LawfulMonad m] {f : β → Bool},
(Std.IterM.filter f it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ =>
if h' : f out = true then pure... | true |
RingPreordering.casesOn | Mathlib.Algebra.Order.Ring.Ordering.Defs | {R : Type u_1} →
[inst : CommRing R] →
{motive : RingPreordering R → Sort u} →
(t : RingPreordering R) →
((toSubsemiring : Subsemiring R) →
(mem_of_isSquare' : ∀ {x : R}, IsSquare x → x ∈ toSubsemiring.carrier) →
(neg_one_notMem' : -1 ∉ toSubsemiring.carrier) →
... | false |
Hindman.FP.below.cons' | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FP a a_1 → Prop} (a : Stream' M)
(m : M) (h : Hindman.FP a.tail m), Hindman.FP.below h → motive a.tail m h → Hindman.FP.below ⋯ | true |
MeasureTheory.addFundamentalInterior_vadd | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {H : Type u_2} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α)
[inst_2 : AddGroup H] [inst_3 : AddAction H α] [VAddCommClass H G α] (g : H),
MeasureTheory.addFundamentalInterior G (g +ᵥ s) = g +ᵥ MeasureTheory.addFundamentalInterior G s | true |
Lean.mkPrivateName | Lean.Modifiers | Lean.Environment → Lean.Name → Lean.Name | true |
CategoryTheory.Functor.FullyFaithful.addMonObj._proof_6 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.OplaxMonoidal] (hF : F.FullyFaithful) (X : C)
[inst_5... | false |
Lean.Meta.Grind.Arith.Cutsat.FindIntValResult.diseq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.Arith.Cutsat.FindIntValResult | true |
_private.Init.Data.Range.Lemmas.0.Std.Legacy.Range.forIn'.loop.match_1.splitter | Init.Data.Range.Lemmas | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((b : β) → motive (ForInStep.done b)) → ((b : β) → motive (ForInStep.yield b)) → motive __do_lift | true |
Real.sinhHomeomorph | Mathlib.Analysis.SpecialFunctions.Arsinh | ℝ ≃ₜ ℝ | true |
AlgCat.ofHom_id | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u) [inst : CommRing R] {X : Type v} [inst_1 : Ring X] [inst_2 : Algebra R X],
AlgCat.ofHom (AlgHom.id R X) = CategoryTheory.CategoryStruct.id (AlgCat.of R X) | true |
Ordnode.valid'_singleton | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {x : α} {o₁ : WithBot α} {o₂ : WithTop α},
Ordnode.nil.Bounded o₁ ↑x → Ordnode.nil.Bounded (↑x) o₂ → Ordnode.Valid' o₁ {x} o₂ | true |
Std.DTreeMap.Internal.Impl.Const.get!_modify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} [Std.TransOrd α] {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β},
t.WF →
∀ {k k' : α} [hi : Inhabited β] {f : β → β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.Const.modify k f t) k' =
if compare k k' = Ordering.eq then (Option.map ... | true |
starMulOfComm._proof_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} (x : R), id (id x) = id (id x) | false |
WittVector.ghostEquiv._proof_4 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (x y : WittVector p R),
(↑↑WittVector.ghostMap).toFun (x + y) = (↑↑WittVector.ghostMap).toFun x + (↑↑WittVector.ghostMap).toFun y | false |
CategoryTheory.Abelian.SpectralObject.instCategory | Mathlib.Algebra.Homology.SpectralObject.Basic | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
CategoryTheory.Category.{max (max u_2 u_3) u_4, max (max (max u_4 u_3) u_2) u_1}
(CategoryTheory.Abelian.Spe... | true |
CategoryTheory.SplitEpi.epi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} (se : CategoryTheory.SplitEpi f),
CategoryTheory.Epi f | true |
Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData.isEmpty | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData → Bool | true |
Turing.ToPartrec.Cfg.ret.injEq | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Cont) (a_1 : List ℕ) (a_2 : Turing.ToPartrec.Cont) (a_3 : List ℕ),
(Turing.ToPartrec.Cfg.ret a a_1 = Turing.ToPartrec.Cfg.ret a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | true |
Topology.IsInducing.continuousAt_iff' | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace Y]
[inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace Z],
Topology.IsInducing f → ∀ {x : X}, Set.range f ∈ nhds (f x) → (ContinuousAt (g ∘ f) x ↔ ContinuousAt g (f x)) | true |
AlternativeMonad.casesOn | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} →
{motive : AlternativeMonad m → Sort u} →
(t : AlternativeMonad m) →
([toAlternative : Alternative m] →
[toBind : Bind m] → motive { toAlternative := toAlternative, toBind := toBind }) →
motive t | false |
MLList.range | Batteries.Data.MLList.Basic | {m : Type → Type} → [Monad m] → MLList m ℕ | true |
SupBotHom.subtypeVal_coe | Mathlib.Order.Hom.BoundedLattice | ∀ {β : Type u_3} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {P : β → Prop} (Pbot : P ⊥)
(Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)), ⇑(SupBotHom.subtypeVal Pbot Psup) = Subtype.val | true |
Tactic.ComputeAsymptotics.WellFormedBasis.of_sublist | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {basis basis' : Tactic.ComputeAsymptotics.Basis},
List.Sublist basis basis' →
Tactic.ComputeAsymptotics.WellFormedBasis basis' → Tactic.ComputeAsymptotics.WellFormedBasis basis | true |
eq_div_of_mul_eq | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b c : G₀}, c ≠ 0 → a * c = b → a = b / c | true |
Ordinal.enumOrd_le_of_forall_lt | Mathlib.SetTheory.Ordinal.Enum | ∀ {o a : Ordinal.{u}} {s : Set Ordinal.{u}}, a ∈ s → (∀ b < o, Ordinal.enumOrd s b < a) → Ordinal.enumOrd s o ≤ a | true |
Lean.Elab.instInhabitedWhereFinallyView.default | Lean.Elab.WhereFinally | Lean.Elab.WhereFinallyView | true |
Mathlib.Meta.NormNum.initFn._@.Mathlib.Tactic.NormNum.Core.1919626320._hygCtx._hyg.2 | Mathlib.Tactic.NormNum.Core | IO Unit | false |
UniformSpace.Completion.addGroup._proof_2 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : IsUniformAddGroup α]
(a : UniformSpace.Completion α), -a + a = 0 | false |
Finset.insertPiProd | Mathlib.Data.Finset.Insert | {α : Type u_1} →
[inst : DecidableEq α] →
{s : Finset α} → {a : α} → (f : α → Type u_3) → ((i : α) → i ∈ insert a s → f i) → f a × ((i : α) → i ∈ s → f i) | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor._proof_4 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {b₀ b₁ b₂ : AlgebraicGeometry.Schemeᵒᵖ} (x : b₀ ⟶ b₁) (x_1 : b₁ ⟶ b₂),
(CategoryTheory.Bicategory.conjugateEquiv
(CategoryTheory.CategoryStruct.comp
((fun {b b'} f =>
{ l := (AlgebraicGeometry.Scheme.Modules.pullback f.unop).toCatHom,
r := (AlgebraicGeometry.Sch... | false |
Lean.Elab.Tactic.ElimApp.Alt.recOn | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimApp.Alt → Sort u} →
(t : Lean.Elab.Tactic.ElimApp.Alt) →
((name : Lean.Name) →
(info : Lean.Meta.ElimAltInfo) →
(mvarId : Lean.MVarId) → motive { name := name, info := info, mvarId := mvarId }) →
motive t | false |
CategoryTheory.Limits.WalkingMulticospan._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} → CategoryTheory.Limits.WalkingMulticospan J → ℕ | false |
CategoryTheory.SingleFunctors.Hom.mk.injEq | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A}
(hom : (a : A) → F.functor a ⟶ G.functor a)
(comm :
autoParam... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_diff._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
LinearMap.lTensor_comp_mk | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P) (m : M),
LinearMap.lTensor M f ∘ₗ (TensorProduct.mk R M N) m = (T... | true |
IO.Process.SpawnArgs.inheritEnv | Init.System.IO | IO.Process.SpawnArgs → Bool | true |
ENNReal.natCast_ne_top._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ (n : ℕ), (↑n = ⊤) = False | false |
CategoryTheory.CostructuredArrow.mapNatIso_functor_map_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S S' : CategoryTheory.Functor C D} (i : S ≅ S')
{X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f : X ⟶ Y),
((CategoryTheory.CostructuredArrow.mapNatIso i).functor.... | true |
Std.ExtTreeSet.isEmpty_eq_false_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [Std.TransCmp cmp], t.isEmpty = false ↔ ¬t = ∅ | true |
CategoryTheory.Limits.biprod.inl_map | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{W X Y Z : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X]
[inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] (f : W ⟶ Y) (g : X ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.... | true |
Subsemiring.op_eq_top | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S : Subsemiring R}, S.op = ⊤ ↔ S = ⊤ | true |
monovaryOn_inv_right₀._simp_1 | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : Semifield β] [inst_2 : LinearOrder β]
[IsStrictOrderedRing β] {s : Set ι} {f : ι → α} {g : ι → β},
(∀ i ∈ s, 0 < g i) → MonovaryOn f g⁻¹ s = AntivaryOn f g s | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.