name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Syntax.ident.elim | Init.Prelude | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
t.ctorIdx = 3 →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive_1 (Lean.Syntax.ident info rawVal val preresolved)) →
motive_1 t | false |
LinearMap.domRestrict₁₂_apply | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module S N]
[inst_9 : Module R₂ P] [inst_10 : Module S₂ P] [inst_11 : SMulCommClass S₂ R₂ P] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
(f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (p : Submodule R M) (q : Submodule S N) (x : ↥p) (y : ↥q),
((f.domRestrict₁₂ p q) x) y = (f ↑x) ↑y | true |
Lean.Elab.Tactic.GuardMsgs.MessageOrdering._sizeOf_inst | Lean.Elab.GuardMsgs | SizeOf Lean.Elab.Tactic.GuardMsgs.MessageOrdering | false |
_private.Mathlib.RepresentationTheory.Rep.Basic.0.Rep.mk.noConfusion | Mathlib.RepresentationTheory.Rep.Basic | {k : Type u} →
{G : Type v} →
{inst : Semiring k} →
{inst_1 : Monoid G} →
{P : Sort u_1} →
{V : Type w} →
{hV1 : AddCommGroup V} →
{hV2 : Module k V} →
{ρ : Representation k G V} →
{V' : Type w} →
{hV1' : AddCommGroup V'} →
{hV2' : Module k V'} →
{ρ' : Representation k G V'} →
{ V := V, hV1 := hV1, hV2 := hV2, ρ := ρ } = { V := V', hV1 := hV1', hV2 := hV2', ρ := ρ' } →
(V = V' → hV1 ≍ hV1' → hV2 ≍ hV2' → ρ ≍ ρ' → P) → P | false |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} (A : Type u') [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : CategoryTheory.Functor.IsDenseSubsite J₀ J F] (data : (X : C) → F.OneHypercoverDenseData J₀ J X)
[CategoryTheory.Limits.HasLimitsOfSize.{w, w, v', u'} A], (F.sheafPushforwardContinuous A J₀ J).EssSurj | true |
HahnEmbedding.Partial.sSup | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
[inst_7 : Module K M] →
[inst_8 : IsOrderedModule K M] →
{R : Type u_3} →
[inst_9 : AddCommGroup R] →
[inst_10 : LinearOrder R] →
[inst_11 : Module K R] →
{seed : HahnEmbedding.Seed K M R} →
[IsOrderedAddMonoid R] →
{c : Set (HahnEmbedding.Partial seed)} →
c.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) c → HahnEmbedding.Partial seed | true |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_2 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_a : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | false |
List.takeD | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → α → List α | true |
UInt16.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt16}, c ≠ -1 → c < c + 1 | true |
Subring.rec | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
[inst : NonAssocRing R] →
{motive : Subring R → Sort u_1} →
((toSubsemiring : Subsemiring R) →
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) →
motive { toSubsemiring := toSubsemiring, neg_mem' := neg_mem' }) →
(t : Subring R) → motive t | false |
UniformEquiv.piCongrLeft | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{ι' : Type u_5} →
{β : ι' → Type u_6} →
[inst : (j : ι') → UniformSpace (β j)] → (e : ι ≃ ι') → ((i : ι) → β (e i)) ≃ᵤ ((j : ι') → β j) | true |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_6 | Mathlib.Order.Filter.ENNReal | ∀ {q : NNReal}, (0 ≤ ↑q) = True | false |
Batteries.RBNode.Balanced.map | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {c : Batteries.RBColor} {n : ℕ} {α_1 : Type u_2} {f : α → α_1} {t : Batteries.RBNode α},
t.Balanced c n → (Batteries.RBNode.map f t).Balanced c n | true |
Lean.PersistentHashMap.isUnaryEntries | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → Option (α × β) → Option (α × β) | true |
coe_setBasisOfLinearIndependentOfCardEqFinrank | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
[inst_3 : Nonempty ↑s] [inst_4 : Fintype ↑s] (lin_ind : LinearIndependent K Subtype.val)
(card_eq : s.toFinset.card = Module.finrank K V),
⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val | true |
BoxIntegral.BoxAdditiveMap.rec | Mathlib.Analysis.BoxIntegral.Partition.Additive | {ι : Type u_3} →
{M : Type u_4} →
[inst : AddCommMonoid M] →
{I : WithTop (BoxIntegral.Box ι)} →
{motive : BoxIntegral.BoxAdditiveMap ι M I → Sort u} →
((toFun : BoxIntegral.Box ι → M) →
(sum_partition_boxes' :
∀ (J : BoxIntegral.Box ι),
↑J ≤ I → ∀ (π : BoxIntegral.Prepartition J), π.IsPartition → ∑ Ji ∈ π.boxes, toFun Ji = toFun J) →
motive { toFun := toFun, sum_partition_boxes' := sum_partition_boxes' }) →
(t : BoxIntegral.BoxAdditiveMap ι M I) → motive t | false |
Lean.Environment.containsOnBranch | Lean.Environment | Lean.Environment → Lean.Name → Bool | true |
Std.DTreeMap.Internal.Impl.Balanced.one_le | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced → 1 ≤ sz | true |
TwoSidedIdeal.orderIsoRingCon_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (self : TwoSidedIdeal R),
TwoSidedIdeal.orderIsoRingCon self = self.ringCon | true |
CategoryTheory.Limits.HasCountableLimits.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
(∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
CategoryTheory.Limits.HasLimitsOfShape J C) →
CategoryTheory.Limits.HasCountableLimits C | false |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.add_mul_ediv_right.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : (c : ℤ) → (∃ n, c = ↑n + 1) → ℤ → 0 < c → Prop) (c : ℤ) (x : ∃ n, c = ↑n + 1) (b : ℤ) (H : 0 < c),
(∀ (w a : ℕ) (H : 0 < ↑w + 1), motive (↑w + 1) ⋯ (Int.ofNat a) H) →
(∀ (k n : ℕ) (H : 0 < ↑k + 1), motive (↑k + 1) ⋯ (Int.negSucc n) H) → motive c x b H | false |
_private.Mathlib.Order.GaloisConnection.Basic.0.isLUB_image2_of_isLUB_isLUB._simp_1_3 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {p : γ → Prop},
(∀ z ∈ Set.image2 f s t, p z) = ∀ x ∈ s, ∀ y ∈ t, p (f x y) | false |
Matrix.single_apply_of_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α] (i : m)
(j : n) (c : α) (i' : m) (j' : n), ¬(i = i' ∧ j = j') → Matrix.single i j c i' j' = 0 | true |
Lean.Lsp.instFromJsonPrepareRenameParams | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.PrepareRenameParams | true |
Std.TreeMap.Raw.maxKey?_eq_none_iff._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.maxKey? = none) = (t.isEmpty = true) | false |
Lean.Elab.Term.ElabElimInfo.ctorIdx | Lean.Elab.App | Lean.Elab.Term.ElabElimInfo → ℕ | false |
Polynomial.isSplittingField_C | Mathlib.FieldTheory.SplittingField.IsSplittingField | ∀ {K : Type v} [inst : Field K] (a : K), Polynomial.IsSplittingField K K (Polynomial.C a) | true |
Std.DHashMap.size_inter_le_size_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], (m₁ ∩ m₂).size ≤ m₂.size | true |
RingHom.liftOfRightInverse._proof_5 | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_3} {B : Type u_1} {C : Type u_2} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (φ : B →+* C),
(fun g => f.liftOfRightInverseAux f_inv hf ↑g ⋯) ((fun φ => ⟨φ.comp f, ⋯⟩) φ) = φ | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast_mem._simp_1_5 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {x y : Sigma β}, (x = y) = (x.fst = y.fst ∧ x.snd ≍ y.snd) | false |
AlgebraicTopology.DoldKan.HigherFacesVanish.induction | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))},
AlgebraicTopology.DoldKan.HigherFacesVanish q φ →
AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1)
(CategoryTheory.CategoryStruct.comp φ
((CategoryTheory.CategoryStruct.id (AlgebraicTopology.AlternatingFaceMapComplex.obj X) +
AlgebraicTopology.DoldKan.Hσ q).f
(n + 1))) | true |
Lean.Parser.Term.open.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
LinearMap.mkContinuous_coe | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Ring 𝕜] [inst_1 : Ring 𝕜₂]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜₂ F]
{σ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ] F) (C : ℝ) (h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖), ↑(f.mkContinuous C h) = f | true |
hnot_sup_self | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢a ⊔ a = ⊤ | true |
CategoryTheory.NatTrans.mk.injEq | Mathlib.CategoryTheory.NatTrans | ∀ {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 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app Y) = CategoryTheory.CategoryStruct.comp (app X) (G.map f))
CategoryTheory.NatTrans.naturality._autoParam)
(app_1 : (X : C) → F.obj X ⟶ G.obj X)
(naturality_1 :
autoParam
(∀ ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app_1 Y) = CategoryTheory.CategoryStruct.comp (app_1 X) (G.map f))
CategoryTheory.NatTrans.naturality._autoParam),
({ app := app, naturality := naturality } = { app := app_1, naturality := naturality_1 }) = (app = app_1) | true |
fwdDiff_const | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (g : G),
(fwdDiff h fun x => g) = fun x => 0 | true |
Nat.sSup_mem | Mathlib.Data.Nat.Lattice | ∀ {s : Set ℕ}, s.Nonempty → BddAbove s → sSup s ∈ s | true |
Lean.Elab.Term.Do.attachJPs | Lean.Elab.Do.Legacy | Array Lean.Elab.Term.Do.JPDecl → Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.Code | true |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.strictOccursMax | Lean.Meta.LevelDefEq | Lean.Level → Lean.Level → Bool | true |
_private.Init.Grind.Ordered.Module.0.Lean.Grind.OrderedAdd.zsmul_le_zsmul._simp_1_1 | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M]
{a b : M}, (0 ≤ a - b) = (b ≤ a) | false |
CategoryTheory.ShortComplex.isoMk._auto_3 | Mathlib.Algebra.Homology.ShortComplex.Basic | Lean.Syntax | false |
SubAddAction.instInhabited.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : VAdd R M], SubAddAction.instInhabited = { default := ⊥ } | true |
Std.DTreeMap.Raw.Const.ofList._auto_1 | Std.Data.DTreeMap.Raw.Basic | Lean.Syntax | false |
RingHom.map_iterate_frobenius | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p] (x : R) (n : ℕ),
g ((⇑(frobenius R p))^[n] x) = (⇑(frobenius S p))^[n] (g x) | true |
PFunctor.Idx | Mathlib.Data.PFunctor.Univariate.Basic | PFunctor.{uA, uB} → Type (max uA uB) | true |
Lean.Meta.Try.Collector.OrdSet.insert | Lean.Meta.Tactic.Try.Collect | {α : Type} → {x : Hashable α} → {x_1 : BEq α} → Lean.Meta.Try.Collector.OrdSet α → α → Lean.Meta.Try.Collector.OrdSet α | true |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.transGen_oneStep_of_isDershowitzMannaLT._simp_1_1 | Mathlib.Data.Multiset.DershowitzManna | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
(a ∈ Multiset.filter p s) = (a ∈ s ∧ p a) | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.discharge?.match_1 | Lean.Meta.Tactic.Grind.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((p : Lean.Expr) → motive (some p)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | false |
ContinuousMap.instNonUnitalCommCStarAlgebra._proof_6 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : NonUnitalCommCStarAlgebra A] (a b c : C(α, A)), a * (b + c) = a * b + a * c | false |
Mathlib.Tactic.Monoidal.instMkEvalWhiskerLeftMonoidalM.match_1 | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | (ctx : Mathlib.Tactic.Monoidal.Context) →
(motive : Option Q(CategoryTheory.MonoidalCategory unknown_1) → Sort u_1) →
(x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) →
((_monoidal : Q(CategoryTheory.MonoidalCategory unknown_1)) → motive (some _monoidal)) →
((x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) → motive x) → motive x | false |
isClosed_Ioo_iff | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsClosed (Set.Ioo a b) ↔ b ≤ a | true |
_private.Mathlib.Algebra.Module.Submodule.Union.0.Submodule.iUnion_ssubset_of_forall_ne_top_of_card_lt._simp_1_1 | Mathlib.Algebra.Module.Submodule.Union | ∀ {α : Type u} {s : Set α}, (s ⊂ Set.univ) = (s ≠ Set.univ) | false |
Submonoid.smulDistribClass | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_4} {S : Type u_5} [inst : SMul M' α] [inst_1 : SMul M' β]
[inst_2 : SMul α β] [inst_3 : SetLike S M'] [h : SMulDistribClass M' α β] (N' : S), SMulDistribClass (↥N') α β | true |
UInt8.mod_eq_of_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a < b → a % b = a | true |
Aesop.RuleBuilderInput.noConfusion | Aesop.Builder.Basic | {P : Sort u} → {t t' : Aesop.RuleBuilderInput} → t = t' → Aesop.RuleBuilderInput.noConfusionType P t t' | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.replace.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (b : β a) (a_1 : α) (b_1 : β a_1)
(es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.replace a b (Std.DHashMap.Internal.AssocList.cons a_1 b_1 es) =
bif a_1 == a then Std.DHashMap.Internal.AssocList.cons a b es
else Std.DHashMap.Internal.AssocList.cons a_1 b_1 (Std.DHashMap.Internal.AssocList.replace a b es) | true |
CategoryTheory.Dial.rightUnitorImpl._proof_1 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X : CategoryTheory.Dial C),
(X.tensorObjImpl CategoryTheory.Dial.tensorUnitImpl).rel =
(CategoryTheory.Subobject.pullback
(CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.rightUnitor X.src).hom
(CategoryTheory.Limits.prod.rightUnitor X.tgt).hom)).obj
X.rel | false |
NumberField.mixedEmbedding.convexBodySum_volume_eq_zero_of_le_zero | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {B : ℝ},
B ≤ 0 → MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) = 0 | true |
iUnion_Iic_eq_Iio_of_lt_of_tendsto | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {ι : Type u_1} {F : Filter ι} [F.NeBot] [inst : ConditionallyCompleteLinearOrder α]
[inst_1 : TopologicalSpace α] [ClosedIicTopology α] {a : α} {f : ι → α},
(∀ (i : ι), f i < a) → Filter.Tendsto f F (nhds a) → ⋃ i, Set.Iic (f i) = Set.Iio a | true |
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : CategoryTheory.Limits.HasBiproductsOfShape J C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete J) C),
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim.inv.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.isoLimit X).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.lift (CategoryTheory.Limits.Pi.π fun j => X.obj { as := j }))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.desc (CategoryTheory.Limits.Sigma.ι fun j => X.obj { as := j }))
(CategoryTheory.Limits.Sigma.isoColimit X).hom)) | true |
MonadControlT | Init.Control.Basic | (Type u → Type v) → (Type u → Type w) → Type (max (max (u + 1) v) w) | true |
Matrix.conjTranspose_reindex | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Star α] (eₘ : m ≃ l) (eₙ : n ≃ o)
(M : Matrix m n α), ((Matrix.reindex eₘ eₙ) M).conjTranspose = (Matrix.reindex eₙ eₘ) M.conjTranspose | true |
Lean.Parser.Attr.tactic_alt.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer | true |
Sum.map_surjective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Surjective (Sum.map f g) ↔ Function.Surjective f ∧ Function.Surjective g | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ext.match_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} {inst : CommRing R} (motive : ValuativeRel R → Prop) (h : ValuativeRel R),
(∀ (vle : R → R → Prop) (vle_total : ∀ (x y : R), vle x y ∨ vle y x)
(vle_trans : ∀ {z y x : R}, vle x y → vle y z → vle x z)
(vle_add : ∀ {x y z : R}, vle x z → vle y z → vle (x + y) z)
(mul_vle_mul_left : ∀ {x y : R}, vle x y → ∀ (z : R), vle (x * z) (y * z))
(vle_mul_cancel : ∀ {x y z : R}, ¬vle z 0 → vle (x * z) (y * z) → vle x y) (not_vle_one_zero : ¬vle 1 0),
motive
{ vle := vle, vle_total := vle_total, vle_trans := vle_trans, vle_add := vle_add,
mul_vle_mul_left := mul_vle_mul_left, vle_mul_cancel := vle_mul_cancel,
not_vle_one_zero := not_vle_one_zero }) →
motive h | false |
Module.Basis.prod_apply_inl_fst | Mathlib.LinearAlgebra.Basis.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_5} {M' : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M']
(b : Module.Basis ι R M) (b' : Module.Basis ι' R M') (i : ι), ((b.prod b') (Sum.inl i)).1 = b i | true |
UInt8.toInt8_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (UInt8.ofNat n).toInt8 = Int8.ofNat n | true |
GradeOrder.wellFoundedGT | Mathlib.Order.Grade | ∀ {α : Type u_3} [inst : Preorder α] (𝕆 : Type u_5) [inst_1 : Preorder 𝕆] [GradeOrder 𝕆 α] [WellFoundedGT 𝕆],
WellFoundedGT α | true |
WeierstrassCurve.Affine.instDecidableEqPoint.decEq._proof_6 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} (a a_1 : R) (a_2 : W'.Nonsingular a a_1)
(b b_1 : R) (b_2 : W'.Nonsingular b b_1),
¬a = b → ¬WeierstrassCurve.Affine.Point.some a a_1 a_2 = WeierstrassCurve.Affine.Point.some b b_1 b_2 | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimageDiagram.eq_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))}
(hF : ∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE ⋯).op)) (X : C)
(y : (F.obj (Opposite.op 0)).obj.obj (Opposite.op X)),
CategoryTheory.coherentTopology.preimageDiagram✝ hF X y =
CategoryTheory.Functor.ofOpSequence
(CategoryTheory.coherentTopology.struct.map✝ (CategoryTheory.coherentTopology.preimageStruct✝ hF X y)) | true |
IsSimpleRing.of_surjective | Mathlib.RingTheory.SimpleRing.Congr | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] [Nontrivial S] (f : R →+* S),
IsSimpleRing R → Function.Surjective ⇑f → IsSimpleRing S | true |
Std.HashSet.getD_union_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ ∪ m₂).getD k fallback = m₂.getD k fallback | true |
Lean.Parser.Term.set_option.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
CircularPartialOrder.toCircularPreorder | Mathlib.Order.Circular | {α : Type u_1} → [self : CircularPartialOrder α] → CircularPreorder α | true |
ModuleCon.mk.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
{M : Type u_3} →
{inst : Add M} →
{inst_1 : SMul S M} →
{P : Sort u} →
{toAddCon : AddCon M} →
{smul : ∀ (s : S) {x y : M}, toAddCon.toSetoid x y → toAddCon.toSetoid (s • x) (s • y)} →
{toAddCon' : AddCon M} →
{smul' : ∀ (s : S) {x y : M}, toAddCon'.toSetoid x y → toAddCon'.toSetoid (s • x) (s • y)} →
{ toAddCon := toAddCon, smul := smul } = { toAddCon := toAddCon', smul := smul' } →
(toAddCon ≍ toAddCon' → P) → P | false |
MonoidHom.compLeftContinuousBounded_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type v} {γ : Type w} (α : Type u_3) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : Monoid β] [inst_3 : BoundedMul β] [inst_4 : ContinuousMul β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : Monoid γ] [inst_7 : BoundedMul γ] [inst_8 : ContinuousMul γ] (g : β →* γ) {C : NNReal}
(hg : LipschitzWith C ⇑g) (f : BoundedContinuousFunction α β),
(MonoidHom.compLeftContinuousBounded α g hg) f = BoundedContinuousFunction.comp (⇑g) hg f | true |
LinearOrderedAddCommMonoidWithTop.toIsOrderedAddMonoid | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} [self : LinearOrderedAddCommMonoidWithTop α], IsOrderedAddMonoid α | true |
IsAntichain.sperner | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : Fintype α] {𝒜 : Finset (Finset α)},
IsAntichain (fun x1 x2 => x1 ⊆ x2) ↑𝒜 → 𝒜.card ≤ (Fintype.card α).choose (Fintype.card α / 2) | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_2 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x z : V},
¬InnerProductGeometry.angle x z = Real.pi →
¬InnerProductGeometry.angle x z = 0 → ¬Real.sin (InnerProductGeometry.angle x z) = 0 | false |
Batteries.BinomialHeap.Imp.FindMin.WF.casesOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{res : Batteries.BinomialHeap.Imp.FindMin α} →
{motive : Batteries.BinomialHeap.Imp.FindMin.WF le res → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin.WF le res) →
((rank : ℕ) →
(before :
∀ {s : Batteries.BinomialHeap.Imp.Heap α},
Batteries.BinomialHeap.Imp.Heap.WF le rank s →
Batteries.BinomialHeap.Imp.Heap.WF le 0 (res.before s)) →
(node : Batteries.BinomialHeap.Imp.HeapNode.WF le res.val res.node rank) →
(next : Batteries.BinomialHeap.Imp.Heap.WF le (rank + 1) res.next) →
motive { rank := rank, before := before, node := node, next := next }) →
motive t | false |
Std.Iterators.Types.TakeWhile.PlausibleStep.recOn | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β]
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} {it : Std.IterM m β}
{motive : (step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.TakeWhile.PlausibleStep it step → Prop}
{step : Std.IterStep (Std.IterM m β) β} (t : Std.Iterators.Types.TakeWhile.PlausibleStep it step),
(∀ {it' : Std.IterM m β} {out : β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.yield it' out))
(a_1 : (P out).Property { down := true }),
motive (Std.IterStep.yield (Std.IterM.takeWhileWithPostcondition P it') out) ⋯) →
(∀ {it' : Std.IterM m β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it')),
motive (Std.IterStep.skip (Std.IterM.takeWhileWithPostcondition P it')) ⋯) →
(∀ (a : it.internalState.inner.IsPlausibleStep Std.IterStep.done), motive Std.IterStep.done ⋯) →
(∀ {it' : Std.IterM m β} {out : β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.yield it' out))
(a_1 : (P out).Property { down := false }), motive Std.IterStep.done ⋯) →
motive step t | false |
CategoryTheory.uliftFunctor | Mathlib.CategoryTheory.Types.Basic | CategoryTheory.Functor (Type u) (Type (max u v)) | true |
Rep.standardComplex.forget₂ToModuleCat | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) → [inst : CommRing k] → [Monoid G] → HomologicalComplex (ModuleCat k) (ComplexShape.down ℕ) | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Additive.0.Option.elim'.match_1.eq_2 | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD_eq_getD_entryAtIdx? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} {i : ℕ} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD t i fallback =
(Std.DTreeMap.Internal.Impl.Const.entryAtIdx? t i).getD fallback | true |
Int64.le_minValue_iff | Init.Data.SInt.Lemmas | ∀ {a : Int64}, a ≤ Int64.minValue ↔ a = Int64.minValue | true |
TensorProduct.instInner | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : InnerProductSpace 𝕜 F] → Inner 𝕜 (TensorProduct 𝕜 E F) | true |
MeasureTheory.integral_union_ae | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{f : X → E} {s t : Set X} {μ : MeasureTheory.Measure X},
MeasureTheory.AEDisjoint μ s t →
MeasureTheory.NullMeasurableSet t μ →
MeasureTheory.IntegrableOn f s μ →
MeasureTheory.IntegrableOn f t μ → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ + ∫ (x : X) in t, f x ∂μ | true |
Nat.le.below.refl | Init.Prelude | ∀ {n : ℕ} {motive : (a : ℕ) → n.le a → Prop}, Nat.le.below ⋯ | true |
Batteries.PairingHeapImp.Heap.foldTreeM._unsafe_rec | Batteries.Data.PairingHeap | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.PairingHeapImp.Heap α → m β | false |
Mathlib.Linter.TextBased.UnicodeLinter.replaceDisallowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Option String | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_5 | Mathlib.NumberTheory.Divisors | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | false |
invMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], invMonoidHom = { toFun := Inv.inv, map_one' := ⋯, map_mul' := ⋯ } | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_6 | Mathlib.Data.Nat.Prime.Defs | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
LeanSearchClient.LoogleResult.recOn | LeanSearchClient.LoogleSyntax | {motive : LeanSearchClient.LoogleResult → Sort u} →
(t : LeanSearchClient.LoogleResult) →
motive LeanSearchClient.LoogleResult.empty →
((a : Array LeanSearchClient.SearchResult) → motive (LeanSearchClient.LoogleResult.success a)) →
((error : String) →
(suggestions : Option (List String)) → motive (LeanSearchClient.LoogleResult.failure error suggestions)) →
motive t | false |
Std.Tactic.BVDecide.BVPred.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVPred → Sort u} →
({w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinPred) →
(rhs : Std.Tactic.BVDecide.BVExpr w) → motive (Std.Tactic.BVDecide.BVPred.bin lhs op rhs)) →
({w : ℕ} →
(expr : Std.Tactic.BVDecide.BVExpr w) → (idx : ℕ) → motive (Std.Tactic.BVDecide.BVPred.getLsbD expr idx)) →
(t : Std.Tactic.BVDecide.BVPred) → motive t | false |
Topology.IsUpperSet.topology_eq_upperSetTopology | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_4} {t : TopologicalSpace α} {inst : Preorder α} [self : Topology.IsUpperSet α], t = Topology.upperSet α | true |
_private.Init.Data.UInt.Lemmas.0.USize.pos_iff_ne_zero._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Vector.back? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → Option α | true |
Units.val_le_val._simp_2 | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (↑a ≤ ↑b) = (a ≤ b) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.