name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Std.Internal.Async.Select.0.Std.Internal.IO.Async.Selectable.one._proof_2 | Std.Internal.Async.Select | ∀ {α : Type} (selectable : Std.Internal.IO.Async.Selectable α), Nonempty (Except IO.Error selectable.β) | false |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.mkExactSuggestionSyntax | Lean.Meta.Tactic.TryThis | Lean.Expr → Bool → Lean.MetaM (Lean.TSyntax `tactic × Lean.MessageData) | true |
DirectedSystem | Mathlib.Order.DirectedInverseSystem | {ι : Type u_1} → [inst : Preorder ι] → (F : ι → Type u_4) → (⦃i j : ι⦄ → i ≤ j → F i → F j) → Prop | true |
AlgEquiv.toLinearEquiv_refl | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁],
AlgEquiv.refl.toLinearEquiv = LinearEquiv.refl R A₁ | true |
CommAlgCat.tensorHom_hom | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] {A B C D : CommAlgCat R} (f : A ⟶ C) (g : B ⟶ D),
CommAlgCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
Algebra.TensorProduct.map (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) | true |
Lean.Elab.Structural.IndGroupInst.levels | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → List Lean.Level | true |
AlgebraicGeometry.instQuasiSeparatedOfMonoScheme | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [CategoryTheory.Mono f], AlgebraicGeometry.QuasiSeparated f | true |
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isNoSpecType | Lean.Compiler.LCNF.SpecInfo | Lean.Environment → Lean.Expr → Bool | true |
Lean.Parser.ParserContext.suppressInsideQuot._inherited_default | Lean.Parser.Types | Bool | false |
EuclideanSpace.nndist_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_7} [inst : RCLike 𝕜] {n : Type u_8} [inst_1 : Fintype n] (x y : EuclideanSpace 𝕜 n),
nndist x y = NNReal.sqrt (∑ i, nndist (x.ofLp i) (y.ofLp i) ^ 2) | true |
CategoryTheory.Grp.mk | Mathlib.CategoryTheory.Monoidal.Grp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(X : C) → [grp : CategoryTheory.GrpObj X] → CategoryTheory.Grp C | true |
Finset.emultiplicity_prod | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {β : Type u_3} {p : α},
Prime p → ∀ (s : Finset β) (f : β → α), emultiplicity p (∏ x ∈ s, f x) = ∑ x ∈ s, emultiplicity p (f x) | true |
Lean.Linter.MissingDocs.handleMutual | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.Handler | true |
RCLike.conjAe_coe | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], ⇑RCLike.conjAe = ⇑(starRingEnd K) | true |
LinearEquiv.ofEq.congr_simp | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p q : Submodule R M) (h : p = q), LinearEquiv.ofEq p q h = LinearEquiv.ofEq p q h | true |
RCLike.im_eq_zero | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], RCLike.I = 0 → ∀ (z : K), RCLike.im z = 0 | true |
CategoryTheory.Limits.BinaryBicone.isBilimitOfCokernelFst._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) {T : C} (f : X ⟶ T) (g : Y ⟶ T),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.BinaryCofan.inl b.toCocone)
((fun {T} f g => CategoryTheory.C... | false |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.Polynomial.flt_catalan_aux._simp_1_5 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) | false |
Std.Format.tag.sizeOf_spec | Init.Data.Format.Basic | ∀ (a : ℕ) (a_1 : Std.Format), sizeOf (Std.Format.tag a a_1) = 1 + sizeOf a + sizeOf a_1 | true |
Filter.EventuallyEq.nhdsNE_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜}, f₁ =ᶠ[nhdsWithin x {x}ᶜ] f → deriv f₁ =ᶠ[nhdsWithin x {x}ᶜ] deriv f | true |
List.le_nil._simp_1 | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] {l : List α}, (l ≤ []) = (l = []) | false |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getMotiveLevel._sparseCasesOn_1 | Lean.Meta.RecursorInfo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
_private.Aesop.Tree.Data.0.Aesop.GoalId.succ.match_1 | Aesop.Tree.Data | (motive : Aesop.GoalId → Sort u_1) → (x : Aesop.GoalId) → ((n : ℕ) → motive { toNat := n }) → motive x | false |
Std.HashMap.Equiv.getElem!_eq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], m₁.Equiv m₂ → m₁[k]! = m₂[k]! | true |
BooleanSubalgebra.topEquiv._proof_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {a b : ↥⊤},
(Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b ↔ (Equiv.Set.univ α) a ≤ (Equiv.Set.univ α) b | false |
Int.Linear.Poly.mul_minus_one_getConst_eq | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (p.mul (-1)).getConst = -p.getConst | true |
NumberField.InfinitePlace.one_le_of_lt_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] [NumberField K] {w : NumberField.InfinitePlace K} {a : NumberField.RingOfIntegers K},
a ≠ 0 → (∀ ⦃z : NumberField.InfinitePlace K⦄, z ≠ w → z ↑a < 1) → 1 ≤ w ↑a | true |
CategoryTheory.Core.functorToCore._proof_4 | Mathlib.CategoryTheory.Core | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : Type u_4} [inst_1 : CategoryTheory.Groupoid G]
(F : CategoryTheory.Functor G C) {X Y : G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Groupoid.inv f)) (F.map f) =
CategoryTheory.CategoryStruct.id { of := F.obj Y }.of | false |
Lean.CollectMVars.State.mk._flat_ctor | Lean.Util.CollectMVars | Lean.ExprSet → Array Lean.MVarId → Lean.CollectMVars.State | false |
WType.toList._sunfold | Mathlib.Data.W.Constructions | (γ : Type u) → WType (WType.Listβ γ) → List γ | false |
Std.TreeMap.getEntryGE | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isGE = true) → α × β | true |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.noConfusion | Lean.Compiler.LCNF.JoinPoints | {P : Sort u} →
{candidates candidates' : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo} →
{ candidates := candidates } = { candidates := candidates' } → (candidates = candidates' → P) → P | false |
CategoryTheory.Quotient.linear._proof_2 | Mathlib.CategoryTheory.Quotient.Linear | ∀ (R : Type u_3) {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] (r : HomRel C)
[inst_4 : CategoryTheory.Congruence r] (hr : ∀ (a : R) ⦃X Y : C⦄ (f₁ f₂ : X ⟶ Y), r f₁ f₂ → r (a • f₁) (a • f₂))
[inst_5 :... | false |
Std.Tactic.BVDecide.BVExpr.Cache.insert.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
(motive : Std.Tactic.BVDecide.BVExpr.Cache aig → Sort u_1) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig) →
((map : Std.DHashMap Std.Tactic.BVDecide.BVExpr.Cache.Key fun k => Vector Std.Sat.AIG.Fanin k.w) →
(hbound :
∀ {i : ℕ} (k : St... | false |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns.match_1 | Mathlib.Tactic.CasesM | (motive : Option (Lean.Expr × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Array Lean.Expr)) →
((fst : Lean.Expr) → motive (some (fst, #[]))) →
((x : Option (Lean.Expr × Array Lean.Expr)) → motive x) → motive __do_lift | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.727354328._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO Unit | false |
Submodule.quotientEquivDirectSum._proof_3 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (F : Type u_4) [inst_6 : CommRing F]
[inst_7 : Algebra F R] [inst_8 : Module F M] [inst_9 : IsScalarTower F R M] (b : Module.... | false |
ContinuousMap.equivFnOfDiscrete_symm_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : DiscreteTopology α]
(f : α → β), ⇑(ContinuousMap.equivFnOfDiscrete.symm f) = f | true |
Lean.Meta.Sym.Simp.instOrElseSimproc | Lean.Meta.Sym.Simp.Simproc | OrElse Lean.Meta.Sym.Simp.Simproc | true |
bot_lt_isotypicComponent | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Submodule R M)
[IsSimpleModule R ↥S], ⊥ < isotypicComponent R M ↥S | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_inter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.hasFDerivAt_of_tendstoLocallyUniformlyOn._simp_1_2 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ {α : Type u_1} {f : Filter α}, (Set.univ ∈ f) = True | false |
Int.emod_minus_one | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ), a % -1 = 0 | true |
CategoryTheory.StructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S S' : D} →
{T : CategoryTheory.Functor C D} →
(S ≅ S') → (CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S' T) | true |
starL.congr_simp | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : TopologicalSpace A]
[inst_7 : ContinuousStar A], starL R = starL R | true |
npow_one | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (x : M), x ^ 1 = x | true |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimp.match_1 | Lean.Elab.Tactic.Conv.Simp | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats → Sort u_1) →
(__discr : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) →
((result : Lean.Meta.Simp.Result) → (snd : Lean.Meta.Simp.Stats) → motive (result, snd)) → motive __discr | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a + -b = 0) = (a = b) | false |
Equiv.Perm.IsSwap.congr_simp | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (f f_1 : Equiv.Perm α), f = f_1 → f.IsSwap = f_1.IsSwap | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_subset_restrict_nonpos'._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | false |
Std.DHashMap.Raw.Const.getThenInsertIfNew? | Std.Data.DHashMap.Raw | {α : Type u} →
{β : Type v} →
[BEq α] → [Hashable α] → (Std.DHashMap.Raw α fun x => β) → α → β → Option β × Std.DHashMap.Raw α fun x => β | true |
Lean.Parser.Command.declVal.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
instLawfulCommIdentityInt64HOrOfNat | Init.Data.SInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ||| x2) 0 | true |
StarAlgHom.prodEquiv._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B]
[inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : Star C],
Function.LeftInverse (fun f => ((StarA... | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1.ctorElimType | ProofWidgets.Data.Html | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} → ℕ → Sort (max 1 u) | false |
InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
InnerProductGeometry.angle x y = 0 → ‖x + y‖ = ‖x‖ + ‖y‖ | true |
Ordering.swap | Init.Data.Ord.Basic | Ordering → Ordering | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Alt pu →
Array (Lean.Compiler.LCNF.Param pu) → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Alt pu | true |
Std.DHashMap.Raw.insert | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Raw α β → (a : α) → β a → Std.DHashMap.Raw α β | true |
Subsemigroup.map_injective_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → Function.Injective (Subsemigroup.map f) | true |
Std.Internal.IO.Async.System.UserId.mk._flat_ctor | Std.Internal.Async.System | ℕ → Std.Internal.IO.Async.System.UserId | false |
CategoryTheory.Limits.preservesLimitsOfSize_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | true |
FirstOrder.Language.Term.substFunc._sunfold | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} → {α : Type u'} → L.Term α → ({n : ℕ} → L.Functions n → L'.Term (Fin n)) → L'.Term α | false |
ZMod.χ₈'_eq_χ₄_mul_χ₈ | Mathlib.NumberTheory.LegendreSymbol.ZModChar | ∀ (a : ZMod 8), ZMod.χ₈' a = ZMod.χ₄ a.cast * ZMod.χ₈ a | true |
Std.IterM.mk.inj | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} {internalState internalState_1 : α},
{ internalState := internalState } = { internalState := internalState_1 } → internalState = internalState_1 | true |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft'._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_3} (P : α → Sort u_2) (e : α ≃ β) (f : (a : α) → P a), (fun x => ⋯ ▸ f (e.symm (e x))) = f | false |
RingHom.FormallyUnramified.holdsForLocalization | Mathlib.RingTheory.RingHom.Unramified | RingHom.HoldsForLocalization fun {R S} [CommRing R] [CommRing S] => RingHom.FormallyUnramified | true |
leftCoset_mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {a : α}, a ∈ s → a • ↑s = ↑s | true |
Int8.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int8.minValue.toInt ≤ x.toInt | true |
_private.Init.Data.Char.Ordinal.0.Char.lt_iff_ofOrdinal_lt._simp_1_1 | Init.Data.Char.Ordinal | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | false |
Continuous.homeoOfEquivCompactToT2 | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → [CompactSpace X] → [T2Space Y] → {f : X ≃ Y} → Continuous ⇑f → X ≃ₜ Y | true |
Filter.EventuallyEq.hasFDerivWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
f₀ =ᶠ[nhdsWithin ... | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_6 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → a ≤ i + 1 | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible._simp_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), (f.mapMatrix M).det = f M.det | false |
LaurentSeries.LaurentSeries_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (x : RatFunc K),
(LaurentSeries.LaurentSeriesPkg K).coe (WithVal.toVal (RatFunc.polynomialValuationX K) x) =
(algebraMap (RatFunc K) (LaurentSeries K)) x | true |
Holor.assocRight | Mathlib.Data.Holor | {α : Type} → {ds₁ ds₂ ds₃ : List ℕ} → Holor α (ds₁ ++ ds₂ ++ ds₃) → Holor α (ds₁ ++ (ds₂ ++ ds₃)) | true |
isStarProjection_iff' | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p : R} [inst : Mul R] [inst_1 : Star R], IsStarProjection p ↔ p * p = p ∧ star p = p | true |
_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower.match_1.eq_1 | Mathlib.Logic.Equiv.Multiset | ∀ (motive : List ℕ → ℕ → Sort u_1) (x : ℕ) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (m : ℕ) → (l : List ℕ) → (n : ℕ) → motive (m :: l) n),
(match [], x with
| [], x => h_1 x
| m :: l, n => h_2 m l n) =
h_1 x | true |
PresheafOfModules.epi_of_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} {f : M₁ ⟶ M₂},
(∀ ⦃X : Cᵒᵖ⦄, Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X))) → CategoryTheory.Epi f | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore EInt
(fun r => ComplexShape.spectralSequenceNat (-r, r - 1)) 2 | true |
Interval.mulOneClass._proof_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s : Interval α),
WithBot.map₂ (fun x1 x2 => x1 * x2) (↑1) s = s | false |
AddCommMonoidWithOne.mk | Mathlib.Data.Nat.Cast.Defs | {R : Type u_2} → [toAddMonoidWithOne : AddMonoidWithOne R] → (∀ (a b : R), a + b = b + a) → AddCommMonoidWithOne R | true |
Lean.Parser.Term.liftMethod._regBuiltin.Lean.Parser.Term.liftMethod.parenthesizer_15 | Lean.Parser.Do | IO Unit | false |
VAdd.ctorIdx | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → VAdd G P → ℕ | false |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] {n : ℕ} {w₁ w₂ : Fin (n + 1) → R} {i : Fin (n + 1)}
(motive : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0 → Prop)
(x : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0),
(∀ (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i)) (h0 : w₁ i ≠ 0... | false |
Std.DTreeMap.Internal.Impl.maxEntry?.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).maxEntry? = some ⟨k, v⟩ | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ}, i + 1 ≤ [].length → i < [].length | false |
Std.Roo._sizeOf_1 | Init.Data.Range.Polymorphic.PRange | {α : Type u} → [SizeOf α] → Std.Roo α → ℕ | false |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.total.match_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ (α : Type u_1) (β : Type u_2)
(motive :
((bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) →
Prop)
(x :
(bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, ... | false |
IsPrimitiveRoot.powerBasis_dim | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] (K : Type u) {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ : L} (hζ : IsPrimitiveRoot ζ n),
(IsPrimitiveRoot.powerBasis K hζ).dim = (minpoly K ζ).natDegree | true |
Pi.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | ∀ {ι : Type u_3} {α : Type u_1} {π : ι → Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α]
[inst_2 : (i : ι) → AddCommMonoid (π i)] [inst_3 : (i : ι) → PartialOrder (π i)]
[inst_4 : (i : ι) → SMulZeroClass α (π i)] [inst_5 : (i : ι) → CeilDiv α (π i)] (_a : α),
0 < _a → ∀ (_f _g : (i : ι) → π i), (∀ (a... | false |
Lean.Compiler.LCNF.Simp.CtorInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | SizeOf Lean.Compiler.LCNF.Simp.CtorInfo | false |
FormalMultilinearSeries.congr_simp | Mathlib.Analysis.Analytic.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | true |
Combinatorics.Line.ColorFocused.distinct_colors | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_5} {ι : Type u_6} {κ : Type u_7} {C : (ι → Option α) → κ} (self : Combinatorics.Line.ColorFocused C),
(Multiset.map Combinatorics.Line.AlmostMono.color self.lines).Nodup | true |
WittVector.IsPoly₂.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {h : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R → WittVector p R}
{f g : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hh : WittVector.IsPoly₂ p h]
[hf : WittVector.IsPoly p f] [hg : WittVector.IsPoly p g], WittVector.IsPoly₂ p fun x _Rcr x_1 y => h (f x_1) (g y) | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Lean.Name → Lean.Name → Lean.Exception → Lean.Meta.RefinedDiscrTree.ImportFailure✝ | false |
CategoryTheory.Adjunction.commShiftIso_hom_app_counit_app_shift_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShi... | true |
Topology.WithUpper | Mathlib.Topology.Order.LowerUpperTopology | Type u_3 → Type u_3 | true |
PFunctor.M.Agree'.recOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop} {a : ℕ}
{a_1 a_2 : F.M} (t : PFunctor.M.Agree' a a_1 a_2),
(∀ (x y : F.M), motive 0 x y ⋯) →
(∀ {n : ℕ} {a : F.A} (x y : F.B a → F.M) {x' y' : F.M} (a_3 : x' = PFunctor.M.mk ⟨a, x⟩)
(a_4 : y' = PFunctor.M... | false |
Option.merge_none_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {f : α → α → α} {b : Option α}, Option.merge f none b = b | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.