name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Triangulated.Subcategory.0.CategoryTheory.ObjectProperty.extensionProduct_retractClosure_retractClosure_le._proof_1_3 | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ] (A B : C)
(f₃ : B ⟶ (CategoryTheory.shiftFunctor C 1).obj A) (A' : C) (a₁ : A ⟶ A') (B' : C) (a₃ : B ⟶ B') (b₃ : B' ⟶ B),
CategoryTheory.CategoryStruct.comp a₃ b₃ = CategoryTheory.CategoryStruct.id B →
Category... | null | false |
Lean.CollectFVars.State.fvarIds._default | Lean.Util.CollectFVars | Array Lean.FVarId | null | false |
Lean.Lsp.instDecidableEqCompletionItemKind._proof_2 | Lean.Data.Lsp.LanguageFeatures | ∀ (x y : Lean.Lsp.CompletionItemKind), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go.induct_unfolding | Init.Data.String.Pattern.String | ∀ (pat : String.Slice)
(motive :
(table : Array ℕ) →
0 < table.size →
table.size ≤ pat.utf8ByteSize →
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → Vector ℕ pat.utf8ByteSize → Prop),
(∀ (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ)... | null | true |
HahnSeries.instIsScalarTower | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] {V : Type u_8} [inst_1 : Monoid R] [inst_2 : AddMonoid V]
[inst_3 : DistribMulAction R V] {S : Type u_9} [inst_4 : Monoid S] [inst_5 : DistribMulAction S V] [inst_6 : SMul R S]
[IsScalarTower R S V], IsScalarTower R S (HahnSeries Γ V) | null | true |
Array.toListLitAux._f | Init.Data.Array.GetLit | {α : Type u_1} →
(xs : Array α) →
(n : ℕ) →
xs.size = n →
(x : ℕ) → Nat.below (motive := fun x => x ≤ xs.size → List α → List α) x → x ≤ xs.size → List α → List α | null | false |
Computation.liftRel_pure_right._simp_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (b : β),
Computation.LiftRel R ca (Computation.pure b) = ∃ a ∈ ca, R a b | null | false |
Lean.Parser.testParseFile | Lean.Parser.Module | Lean.Environment → System.FilePath → IO Lean.Syntax | null | true |
Set.Finite.eq_insert_of_subset_of_encard_eq_succ | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s.Finite → s ⊆ t → t.encard = s.encard + 1 → ∃ a, t = insert a s | null | true |
Lean.Expr.getRevArg!._sunfold | Lean.Expr | Lean.Expr → ℕ → Lean.Expr | null | false |
HomologicalComplex.homologyι_singleObjOpcyclesSelfIso_inv | Mathlib.Algebra.Homology.SingleHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
(A : C),
CategoryTheory.CategoryStruct.comp (((HomologicalComplex.single C c j).obj A).... | null | true |
Array.countP_push_of_neg | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {xs : Array α}, ¬p a = true → Array.countP p (xs.push a) = Array.countP p xs | null | true |
Submodule.moduleSubmodule._proof_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Submodule R M), 1 • b = b | null | false |
_private.Lean.DocString.Syntax.0.Lean.Doc.Syntax.link._regBuiltin.Lean.Doc.Syntax.link.docString_1 | Lean.DocString.Syntax | IO Unit | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
Mathlib.Tactic.Echelon.IsPivotedList.below.nil | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α]
{motive : (a : List (Fin n)) → (a_1 : List (List α)) → Mathlib.Tactic.Echelon.IsPivotedList a a_1 → Prop}
{rows : List (List α)} (hz : rows = List.map (fun x => List.replicate n 0) rows),
Mathlib.Tactic.Echelon.IsPivotedList.below ⋯ | null | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.mkSyntaxAndPat | Lean.Elab.MacroArgUtil | Option Lean.Ident → Lean.Term → Lean.TSyntax `stx → Lean.Elab.Command.CommandElabM (Lean.TSyntax `stx × Lean.Term) | null | true |
Odd.pow_injective | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Odd n → Function.Injective fun x => x ^ n | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.and_eq_neg_one_iff._simp_1_2 | Init.Data.UInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w) | null | false |
Set.isUnit_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : DivisionMonoid α] {s : Set α}, IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.State.mk.inj | Lean.Compiler.LCNF.InferBorrow | ∀ {owned : Lean.FVarIdHashSet} {modified : Bool} {paramMap : Lean.Compiler.LCNF.ParamMap✝}
{owned_1 : Lean.FVarIdHashSet} {modified_1 : Bool} {paramMap_1 : Lean.Compiler.LCNF.ParamMap✝},
{ owned := owned, modified := modified, paramMap := paramMap } =
{ owned := owned_1, modified := modified_1, paramMap := pa... | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH._sparseCasesOn_1 | Lean.Meta.IndPredBelow | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.lcs.match_8 | Lean.Util.Diff | {α : Type} →
(left right : Subarray α) →
(motive : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right)) → Sort u_1) →
(best : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right))) →
((fst : ℕ) →
(v : α) →
(li : Fin (Std.Slice.size left)... | null | false |
ImportGraph.Widget.CopyProps.noConfusion | ImportGraph.Widget.Copy | {P : Sort u} → {t t' : ImportGraph.Widget.CopyProps} → t = t' → ImportGraph.Widget.CopyProps.noConfusionType P t t' | null | false |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse._proof_5 | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ} (φ : T₁ ⟶ T₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk T₂.mor₂.unop T₂.mor₁.unop
(CategoryTheory.Category... | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.finset_inf_span_singleton._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | null | false |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_or._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
fromModuleCatToModuleCatLinearEquivtoModuleCatObj.eq_1 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u) {ι : Type v} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (i : ι),
fromModuleCatToModuleCatLinearEquivtoModuleCatObj R M i =
{ toFun := (AddEquiv.refl ↑(((ModuleCat.toMatrixModCat R ι).comp (MatrixModCat.toModuleCat R... | null | true |
Lean.Widget.instToJsonRpcEncodablePacket.toJson._@.Lean.Widget.InteractiveGoal.1924226853._hygCtx._hyg.48 | Lean.Widget.InteractiveGoal | Lean.Widget.RpcEncodablePacket✝ → Lean.Json | null | false |
Pi.counit_comp_finsuppLcoeFun | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M],
CoalgebraStruct.counit ∘ₗ Finsupp.lcoeFun = CoalgebraStruct.counit | null | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.congr_simp | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (f f_1 : A₀.a ⟶ A₁.a) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f),
{ f := f, h := h } = { f := f_1, h... | null | true |
MultilinearMap.mk._flat_ctor | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
... | null | false |
HomologicalComplex.singleMapHomologicalComplex_inv_app_ne | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] [inst_4 : CategoryTheory.Limits.HasZeroObject W₁]
[inst_5 : Cat... | null | true |
MvPolynomial.monomial_one_mul_cancel_right_iff | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {m : σ →₀ ℕ},
p * (MvPolynomial.monomial m) 1 = q * (MvPolynomial.monomial m) 1 ↔ p = q | null | true |
CategoryTheory.MonoidalCategoryStruct.recOn | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[𝒞 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.MonoidalCategoryStruct C → Sort u_1} →
(t : CategoryTheory.MonoidalCategoryStruct C) →
((tensorObj : C → C → C) →
(whiskerLeft : (X : C) → {Y₁ Y₂ : C} → (Y₁ ⟶ Y₂) → (tensorObj X Y₁ ⟶ tensorObj X Y₂)) →
... | null | false |
Encodable.decodeSum.eq_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Encodable β] (n : ℕ),
Encodable.decodeSum n =
match n.bodd, n.div2 with
| false, m => Option.map Sum.inl (Encodable.decode m)
| x, m => Option.map Sum.inr (Encodable.decode m) | null | true |
_private.Mathlib.Topology.ContinuousMap.StoneWeierstrass.0.ContinuousMap.ker_evalStarAlgHom_inter_adjoin_id._simp_1_5 | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
SemiRingCat.FilteredColimits.semiringObj._aux_8 | Mathlib.Algebra.Category.Ring.FilteredColimits | {J : Type u_2} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J SemiRingCat) →
(j : J) → NSMul (((F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)).comp (CategoryTheory.forget MonCat)).obj j) | null | false |
Lean.Grind.PowIdentity.rec | Init.Grind.Ring.Basic | {α : Type u} →
[inst : Lean.Grind.CommSemiring α] →
{p : ℕ} →
{motive : Lean.Grind.PowIdentity α p → Sort u_1} →
((pow_eq : ∀ (x : α), x ^ p = x) → motive ⋯) → (t : Lean.Grind.PowIdentity α p) → motive t | null | false |
ZFSet.Hereditarily.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (p : ZFSet.{u_1} → Prop) (x : ZFSet.{u_1}), ZFSet.Hereditarily p x = (p x ∧ ∀ y ∈ x, ZFSet.Hereditarily p y) | null | true |
scalarSMulCLE._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ (H : Type u_1) [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H], ContinuousConstSMul ℂˣ H | null | false |
IsUniformInducing.isUltraUniformity | Mathlib.Topology.UniformSpace.Ultra.Completion | ∀ {X : Type u_1} {Y : Type u_2} [inst : UniformSpace X] [inst_1 : UniformSpace Y] [IsUltraUniformity Y] {f : X → Y},
IsUniformInducing f → IsUltraUniformity X | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._proof_28 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B],
autoParam
(∀ {a b c : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} {f g : a ⟶ b} {h i : b ⟶ c} (η : f ⟶ g)
(θ : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_9 f θ)
(Categ... | null | false |
Submodule.instIsModularLattice | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_10} {M : Type u_11} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsModularLattice (Submodule R M) | null | true |
BoundedOrderHom.toOrderHom | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedOrderHom α β → α →o β | null | true |
HomologicalComplex₂.totalFlipIso_hom_f_D₁ | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c]
[inst_3 : TotalComplexShap... | null | true |
CategoryTheory.Limits.HasImage.exists_image | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y}
[self : CategoryTheory.Limits.HasImage f], Nonempty (CategoryTheory.Limits.ImageFactorisation f) | `HasImage f` means that there exists an image factorisation of `f`. | true |
LinearOrder.OfStdArgs.isLinearOrder | Mathlib.Order.Std | ∀ {α : Type u_1} (self : LinearOrder.OfStdArgs α),
let this := self.le;
Std.IsLinearOrder α | ≤ forms a linear order. | true |
CategoryTheory.ShortComplex.homologyFunctorIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory... | null | false |
_private.Std.Data.String.ToInt.0.String.Slice.isInt_iff._simp_1_4 | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.isNat = s.toNat?.isSome | null | false |
Turing.ToPartrec.Code.fix.sizeOf_spec | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Code), sizeOf a.fix = 1 + sizeOf a | null | true |
ContinuousMap.continuousAt | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (x : α),
ContinuousAt (⇑f) x | Deprecated. Use `map_continuousAt` instead. | true |
LinearMap.mapMatrix_neg | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_4} {S : Type u_5} {α : Type u_8} {β : Type u_9} [inst : Semiring R]
[inst_1 : Semiring S] {σᵣₛ : R →+* S} [inst_2 : AddCommMonoid α] [inst_3 : AddCommGroup β] [inst_4 : Module R α]
[inst_5 : Module S β] (f : α →ₛₗ[σᵣₛ] β), (-f).mapMatrix = -f.mapMatrix | null | true |
CategoryTheory.Limits.Types.Pushout.Rel'.inr_inl | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} (s : S),
CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr ((CategoryTheory.ConcreteCategory.hom g) s))
(Sum.inl ((CategoryTheory.ConcreteCategory.hom f) s)) | null | true |
SSet.π₀.lift | Mathlib.AlgebraicTopology.SimplicialSet.PiZero | {X : SSet} →
{T : Type u_1} →
(f : X.obj (Opposite.op { len := 0 }) → T) →
(∀ ⦃x₀ x₁ : X.obj (Opposite.op { len := 0 })⦄ (x : SSet.Edge x₀ x₁), f x₀ = f x₁) → X.π₀ → T | Constructor for maps from the type of connected components of a simplicial set. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.formula3._simp_1_1 | Mathlib.NumberTheory.FLT.Three | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | null | false |
RelSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).last = f p.last | null | true |
Matroid.IsBase.compl_isBase_of_dual | Mathlib.Combinatorics.Matroid.Dual | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M✶.IsBase B → M.IsBase (M.E \ B) | null | true |
MeasureTheory.measure_union_lt_top_iff | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
μ (s ∪ t) < ⊤ ↔ μ s < ⊤ ∧ μ t < ⊤ | null | true |
Lean.PrettyPrinter.Parenthesizer.Context._sizeOf_1 | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.Context → ℕ | null | false |
Lean.logInfo | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.MessageData → m Unit | Log a new information message using the given message data. The position is provided by `getRef`. | true |
ContinuousLinearEquiv.coe_inj | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | true |
Std.DTreeMap.isEmpty_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.keys.isEmpty = t.isEmpty | null | true |
Finset.sdiff_eq_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = {x ∈ s₁ | x ∉ s₂} | null | true |
_private.Std.Data.TreeMap.Raw.Lemmas.0.Std.TreeMap.Raw.Equiv.trans.match_1_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp}
(motive : t₁.Equiv t₂ → t₂.Equiv t₃ → Prop) (x : t₁.Equiv t₂) (x_1 : t₂.Equiv t₃),
(∀ (h : t₁.inner.Equiv t₂.inner) (h' : t₂.inner.Equiv t₃.inner), motive ⋯ ⋯) → motive x x_1 | null | false |
Nat.twoStepInduction | Mathlib.Data.Nat.Init | {motive : ℕ → Sort u_1} →
motive 0 → motive 1 → ((n : ℕ) → motive n → motive (n + 1) → motive (n + 2)) → (a : ℕ) → motive a | Induction principle deriving the next case from the two previous ones. | true |
Fin.coe_divNat | Batteries.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m * n)), ↑i.divNat = ↑i / n | null | true |
Metric.hausdorffEDist_ne_top_of_nonempty_of_bounded | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α},
s.Nonempty → t.Nonempty → Bornology.IsBounded s → Bornology.IsBounded t → Metric.hausdorffEDist s t ≠ ⊤ | If two sets are nonempty and bounded in a metric space, they are at finite Hausdorff
edistance. | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._proof_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → ∀ x ∈ Set.Icc b (b + c), x ∈ Set.uIcc a (b + c) | null | false |
continuousAt_sign_of_neg | Mathlib.Topology.Instances.Sign | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] [inst_2 : PartialOrder α] [inst_3 : DecidableLT α]
[OrderTopology α] {a : α}, a < 0 → ContinuousAt (⇑SignType.sign) a | null | true |
_private.Lean.Meta.Tactic.Induction.0.Lean.MVarId.induction.match_1 | Lean.Meta.Tactic.Induction | (motive : Option ℕ → Sort u_1) →
(paramPos? : Option ℕ) → (Unit → motive none) → ((paramPos : ℕ) → motive (some paramPos)) → motive paramPos? | null | false |
PNat.XgcdType | Mathlib.Data.PNat.Xgcd | Type | A term of `XgcdType` is a system of six naturals. They should
be thought of as representing the matrix
`[[w, x], [y, z]] = [[wp + 1, x], [y, zp + 1]]`
together with the vector `[a, b] = [ap + 1, bp + 1]`.
| true |
Valuation.is_topological_valuation | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3} [inst_2 : LinearOrderedCommGroupWithZero Γ₀]
[inst_3 : TopologicalSpace R] (v : Valuation R Γ₀) [v.Compatible] [IsValuativeTopology R] (s : Set R),
s ∈ nhds 0 ↔ ∃ γ, {x | v.restrict x < ↑γ} ⊆ s | **Alias** of `Valuation.mem_nhds_zero_iff`. | true |
IsApproximateAddSubgroup.addSubgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] [AddSubgroupClass S G] {H : S},
IsApproximateAddSubgroup 1 ↑H | null | true |
CommBialgCat.isoMk | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
{x : CommRing X} → {x_1 : CommRing Y} → {x_2 : Bialgebra R X} → {x_3 : Bialgebra R Y} → (X ≃ₐc[R] Y) → (↧X ≅ ↧Y) | Build an isomorphism in the category `CommBialgCat R` from a `BialgEquiv` between
`Bialgebra`s. | true |
AlgebraicClosure.instCommRing._proof_34 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (a b : AlgebraicClosure k), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
RestrictedProduct.continuous_eval | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
(i : ι), Continuous fun x => x i | null | true |
Std.DTreeMap.Raw.size_le_size_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, t.size ≤ (t.insertIfNew k v).size | null | true |
Std.HashMap.values | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List β | Returns a list of all values present in the hash map in some order. | true |
Std.HashMap.Raw.getKey?_filter_key | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → Bool} {k : α},
m.WF → (Std.HashMap.Raw.filter (fun k x => f k) m).getKey? k = Option.filter f (m.getKey? k) | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.const.eq_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | ∀ (c : ℝ) (basis_hd : ℝ → ℝ) (basis_tl : List (ℝ → ℝ)),
Tactic.ComputeAsymptotics.MultiseriesExpansion.const (basis_hd :: basis_tl) c =
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk
(Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.const basis_hd basis_tl c) fun x => c | null | true |
VSub.casesOn | Mathlib.Algebra.Notation.Defs | {G : Type u_1} →
{P : Type u_2} →
{motive : VSub G P → Sort u} → (t : VSub G P) → ((vsub : P → P → G) → motive { vsub := vsub }) → motive t | null | false |
Lex.instDivisionRing._proof_3 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K],
autoParam (∀ (n : ℕ) (a : Lex K), a ^ ↑n.succ = a ^ ↑n * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
Module.Basis.ofSplitExact._proof_3 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_2} {M : Type u_4} {K : Type u_6} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup K] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R K] [inst_6 : Module R P]
{f : K →ₗ[R] M} {g : M →ₗ[R] P} {s : M →ₗ[R] K},
s ∘ₗ f = LinearMap.id →
Function.Exact ... | null | false |
Std.IterM.mk.injEq | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (internalState internalState_1 : α),
({ internalState := internalState } = { internalState := internalState_1 }) = (internalState = internalState_1) | null | true |
CategoryTheory.WithInitial.mapId | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.WithInitial.map (CategoryTheory.Functor.id C) ≅
CategoryTheory.Functor.id (CategoryTheory.WithInitial C) | A natural isomorphism between the functor `map (𝟭 C)` and `𝟭 (WithInitial C)`. | true |
Lean.Elab.Command.Scope.varUIds._default | Lean.Elab.Command.Scope | Array Lean.Name | null | false |
CategoryTheory.ShortComplex.Splitting.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp e.inv.τ₃ (CategoryTheory.CategoryStruct.comp s.s e.hom.τ₂)) S₂... | null | false |
_private.Mathlib.Order.Filter.ListTraverse.0.Filter.mem_traverse.match_1_7 | Mathlib.Order.Filter.ListTraverse | ∀ {α β γ : Type u_1} {f : β → Filter α} {s : γ → Set α},
let funType_1 := fun x x_1 x_2 => traverse s x_1 ∈ traverse f x;
∀
(motive :
(x : List β) → (x_1 : List γ) → (x_2 : List.Forall₂ (fun b c => s c ∈ f b) x x_1) → List.Forall₂.below x_2 → Prop)
(x : List β) (x_1 : List γ) (x_2 : List.Forall₂ (fun ... | null | false |
Lean.Grind.Ring.neg_zsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (i : ℤ) (a : α), -i • a = -(i • a) | Scalar multiplication by the negation of an integer is the negation of scalar multiplication by that integer. | true |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{id id' : ℕ} →
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id' →
(id = id' → P) → P | null | false |
HasFDerivAt.sub_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (c : F), HasFDerivAt f f' x → HasFDerivAt (fun x => f x - c) f' x | **Alias** of the reverse direction of `hasFDerivAt_sub_const_iff`. | true |
Mathlib.Meta.NormNum.isNat_abs_nonneg | Mathlib.Tactic.NormNum.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Lattice α] [IsOrderedRing α] {a : α} {na : ℕ},
Mathlib.Meta.NormNum.IsNat a na → Mathlib.Meta.NormNum.IsNat |a| na | null | true |
Pi.single_mul_left_apply | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i j : ι) (a : α i)
(f : (i : ι) → α i), Pi.single i (a * f i) j = Pi.single i a j * f j | null | true |
instHasCountableLimitsLightCondMod | Mathlib.Condensed.Light.Limits | ∀ (R : Type u) [inst : Ring R], CategoryTheory.Limits.HasCountableLimits (LightCondMod R) | null | true |
AddCommGroupWithOne.toNatCast | Mathlib.Data.Int.Cast.Defs | {R : Type u} → [self : AddCommGroupWithOne R] → NatCast R | null | true |
Affine.Simplex.centroid_reindex | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {m n : ℕ} (s : Affine.Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)),
(s.reindex e).centroid = s.centroid | null | true |
ENNReal.div_lt_top | Mathlib.Basic.ENNReal.Inv | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ 0 → x / y < ⊤ | null | true |
List.length_range | Init.Data.List.Range | ∀ {n : ℕ}, (List.range n).length = n | null | true |
MeasureTheory.integral_union_eq_left_of_forall | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} {f : X → E},
MeasurableSet t → (∀ x ∈ t, f x = 0) → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.