name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom._default | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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} →
{inst_2 : CategoryTheory.MonoidalCategoryStruct C} →
(actionObj : C → D → D) →
({c c' : C} → (c ⟶ c') → (d : D) → actionObj c d ⟶ actionObj c' d) ... | false |
Lean.Lsp.instFileSourceSignatureHelpParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.SignatureHelpParams | true |
_private.Mathlib.Computability.TuringDegree.0.instPreorderPFunNat | Mathlib.Computability.TuringDegree | Preorder (ℕ →. ℕ) | true |
Lean.IR.Checker.markIndex | Lean.Compiler.IR.Checker | Lean.IR.Index → Lean.IR.Checker.M Unit | true |
Option.filter_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α}, Option.filter p (some a) = if p a = true then some a else none | true |
MvPowerSeries.instInv | Mathlib.RingTheory.MvPowerSeries.Inverse | {σ : Type u_1} → {k : Type u_3} → [Field k] → Inv (MvPowerSeries σ k) | true |
Lean.Elab.Tactic.closeMainGoal | Lean.Elab.Tactic.Basic | Lean.Name → Lean.Expr → optParam Bool true → Lean.Elab.Tactic.TacticM Unit | true |
Lean.Elab.GoalsAtResult | Lean.Server.InfoUtils | Type | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.ListOfFn.0.Set.mem_list_prod._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u} {P : List α → Prop}, (∃ l, P l) = ∃ n f, P (List.ofFn f) | false |
FirstOrder.Language.BoundedFormula.all_iff_not_ex_not | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ} (φ : L.BoundedFormula α (n + 1)),
T.Iff φ.all φ.not.ex.not | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.derivedLitsInvariant_confirmRupHint._proof_1_14 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ (rupHints : Array ℕ) (i : Fin rupHints.size), ↑i + 1 ≤ rupHints.size → ↑i < rupHints.size | false |
Lean.Lsp.instToJsonChangeAnnotation.toJson | Lean.Data.Lsp.Basic | Lean.Lsp.ChangeAnnotation → Lean.Json | true |
Lean.Lsp.instFromJsonCallHierarchyPrepareParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.CallHierarchyPrepareParams | true |
HomologicalComplex.homotopyCofiber.XIsoBiprod.congr_simp | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i j : ι) (hij : c.Rel i j)
[inst_4 : CategoryTheor... | true |
AntitoneOn.Ico | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f g : α → β} {s : Set α},
AntitoneOn f s → MonotoneOn g s → MonotoneOn (fun x => Set.Ico (f x) (g x)) s | true |
List.reduceOption_cons_of_some | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (x : α) (l : List (Option α)), (some x :: l).reduceOption = x :: l.reduceOption | true |
Ordinal.invVeblen₂_gamma | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), o.gamma.invVeblen₂ = 0 | true |
IsJordan.mk._flat_ctor | Mathlib.Algebra.Jordan.Basic | ∀ {A : Type u_1} [inst : Mul A],
(∀ (a b : A), a * b * a = a * (b * a)) →
(∀ (a b : A), a * a * (a * b) = a * (a * a * b)) →
(∀ (a b : A), a * a * (b * a) = a * a * b * a) →
(∀ (a b : A), a * b * (a * a) = a * (b * (a * a))) →
(∀ (a b : A), b * a * (a * a) = b * (a * a) * a) → IsJordan A | false |
_private.Mathlib.Data.Nat.ChineseRemainder.0.Nat.modEq_list_map_prod_iff._simp_1_2 | Mathlib.Data.Nat.ChineseRemainder | ∀ {k : ℕ} {l : List ℕ}, k.Coprime l.prod = ∀ n ∈ l, k.Coprime n | false |
_private.Mathlib.RingTheory.Coalgebra.GroupLike.0.isGroupLikeElem_self._simp_1_1 | Mathlib.RingTheory.Coalgebra.GroupLike | ∀ (R : Type u_2) {A : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A] (a : A),
IsGroupLikeElem R a = (CoalgebraStruct.counit a = 1 ∧ CoalgebraStruct.comul a = a ⊗ₜ[R] a) | false |
Combinatorics.Line._sizeOf_inst | Mathlib.Combinatorics.HalesJewett | (α : Type u_5) → (ι : Type u_6) → [SizeOf α] → [SizeOf ι] → SizeOf (Combinatorics.Line α ι) | false |
iSup_subtype' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {p : ι → Prop} {f : (i : ι) → p i → α},
⨆ i, ⨆ (h : p i), f i h = ⨆ x, f ↑x ⋯ | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_430 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g (g a)}.card) + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g (g ... | false |
BitVec.msb_twoPow | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ}, (BitVec.twoPow w i).msb = (decide (i < w) && decide (i = w - 1)) | true |
GrpCat.SurjectiveOfEpiAuxs.tau._proof_1 | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B), ∃ y, y • ↑(GrpCat.Hom.hom f).range = ↑(GrpCat.Hom.hom f).range | false |
MulAction.isPreprimitive_stabilizer_of_surjective | Mathlib.GroupTheory.Perm.MaximalSubgroups | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (s : Set α),
Function.Surjective MulAction.toPerm → MulAction.IsPreprimitive ↥(MulAction.stabilizer M s) ↑s | true |
HomologicalComplex.dFrom_eq | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.dFrom i = CategoryTheory.CategoryStruct.comp (C.d i j) (C.xNextIso r).inv | true |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.UserWidget.577854155._hygCtx._hyg.1.recOn | Lean.Widget.UserWidget | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) → ((widgets : Lean.Json) → motive { widgets := widgets }) → motive t | false |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.model_distinctConstantsTheory._simp_1_1 | Mathlib.ModelTheory.Semantics | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
Ordinal.omega | Mathlib.SetTheory.Cardinal.Aleph | Ordinal.{u_1} ↪o Ordinal.{u_1} | true |
AddChar.circleEquivComplex._proof_5 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Finite α] (ψ : AddChar α ℂ),
(fun ψ => AddChar.toMonoidHomEquiv.symm (Circle.coeHom.comp ψ.toMonoidHom))
((fun ψ => { toFun := fun a => ⟨ψ a, ⋯⟩, map_zero_eq_one' := ⋯, map_add_eq_mul' := ⋯ }) ψ) =
ψ | false |
Batteries.Tactic.Lint.isAutoDecl | Batteries.Tactic.Lint.Basic | Lean.Name → Lean.CoreM Bool | true |
CategoryTheory.Mon.tensorUnit_mul | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.MonObj.mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | true |
DirectLimit.instMulDistribMulActionOfMulActionHomClass._proof_4 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι... | false |
_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... | false |
Lean.CollectFVars.State.fvarIds._default | Lean.Util.CollectFVars | Array Lean.FVarId | false |
Lean.Lsp.instDecidableEqCompletionItemKind._proof_2 | Lean.Data.Lsp.LanguageFeatures | ∀ (x y : Lean.Lsp.CompletionItemKind), ¬x.ctorIdx = y.ctorIdx → x = y → False | false |
Lean.Server.Watchdog.WorkerState.ctorIdx | Lean.Server.Watchdog | Lean.Server.Watchdog.WorkerState → ℕ | 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 : ℕ)... | 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) | true |
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 | false |
Lean.Parser.testParseFile | Lean.Parser.Module | Lean.Environment → System.FilePath → IO (Lean.TSyntax `Lean.Parser.Module.module) | 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 | true |
Lean.Expr.getRevArg!._sunfold | Lean.Expr | Lean.Expr → ℕ → Lean.Expr | 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).... | 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 | 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 | 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) | false |
_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) | 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 | 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) | false |
Set.isUnit_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : DivisionMonoid α] {s : Set α}, IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a | 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 := p... | 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 | 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)... | false |
AddSubgroup.Normal.hcongr_3 | Mathlib.GroupTheory.IsSubnormal | ∀ (A A' : Type u_2),
A = A' →
∀ (inst : AddGroup A) (inst' : AddGroup A'),
inst ≍ inst' → ∀ (H : AddSubgroup A) (H' : AddSubgroup A'), H ≍ H' → H.Normal ≍ H'.Normal | true |
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... | 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) | 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) | 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 (... | true |
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 | 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... | 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₂] →
... | 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... | 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 | 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₂)) →
... | 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.boddDiv2 with
| (false, m) => Option.map Sum.inl (Encodable.decode m)
| (fst, m) => Option.map Sum.inr (Encodable.decode m) | 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) | 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) | true |
scalarSMulCLE._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ (H : Type u_1) [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H], ContinuousConstSMul ℂˣ H | 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 | 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... | false |
Submodule.instIsModularLattice | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsModularLattice (Submodule R M) | 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 β | 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... | 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) | 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... | false |
ComputeAsymptotics.MultiseriesExpansion.Multiseries.tail_nil | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : ComputeAsymptotics.Basis},
ComputeAsymptotics.MultiseriesExpansion.Multiseries.nil.tail = ComputeAsymptotics.MultiseriesExpansion.Multiseries.nil | true |
Turing.ToPartrec.Code.fix.sizeOf_spec | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Code), sizeOf a.fix = 1 + sizeOf a | true |
ContinuousMap.continuousAt | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (x : α),
ContinuousAt (⇑f) x | true |
LinearMap.mapMatrix_neg | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {S : Type u_8} {α : Type u_11} {β : Type u_12} [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 | 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 (g s)) (Sum.inl (f s)) | 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) | 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 | 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) | 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 < ⊤ | true |
Lean.PrettyPrinter.Parenthesizer.Context._sizeOf_1 | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.Context → ℕ | false |
Lean.logInfo | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.MessageData → m Unit | true |
ContinuousLinearEquiv.coe_inj | Mathlib.Topology.Algebra.Module.Equiv | ∀ {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... | true |
Std.DTreeMap.isEmpty_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.keys.isEmpty = t.isEmpty | true |
Finset.sdiff_eq_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = {x ∈ s₁ | x ∉ s₂} | 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 | false |
Nat.twoStepInduction | Mathlib.Data.Nat.Init | {P : ℕ → Sort u_1} → P 0 → P 1 → ((n : ℕ) → P n → P (n + 1) → P (n + 2)) → (a : ℕ) → P a | true |
Fin.coe_divNat | Batteries.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m * n)), ↑i.divNat = ↑i / n | 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 ≠ ⊤ | 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) | 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 | 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? | false |
PNat.XgcdType | Mathlib.Data.PNat.Xgcd | Type | true |
Valuation.is_topological_valuation | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3}
[inst_2 : LinearOrderedCommGroupWithZero Γ₀] [inst_3 : TopologicalSpace R] [IsValuativeTopology R]
(v : Valuation R Γ₀) [v.Compatible] (s : Set R), s ∈ nhds 0 ↔ ∃ γ, {x | v.restrict x < ↑γ} ⊆ s | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.