name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WittVector.Isocrystal | Mathlib.RingTheory.WittVector.Isocrystal | (p : ℕ) →
[Fact (Nat.Prime p)] →
(k : Type u_1) →
[inst : CommRing k] → [CharP k p] → [PerfectRing k p] → (V : Type u_2) → [AddCommGroup V] → Type (max u_1 u_2) | true |
OpenAddSubgroup.mem_top._simp_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (x : G), (x ∈ ⊤) = True | false |
Aesop.preprocessRule | Aesop.Search.RuleSelection | Aesop.SafeRule | true |
Ordinal.bsup_eq_sup' | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (f : ι → Ordinal.{max u_4 u_5}),
(Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = iSup f | true |
Nat.Prime.pow_inj' | Mathlib.Data.Nat.Prime.Int | ∀ {p q m n : ℕ}, Nat.Prime p → Nat.Prime q → m ≠ 0 → n ≠ 0 → p ^ m = q ^ n → p = q ∧ m = n | true |
_private.Mathlib.Data.ENat.Basic.0.ENat.coe_ne_top.match_1_1 | Mathlib.Data.ENat.Basic | ∀ (a : ℕ) (motive : ↑a = ⊤ → Prop) (a : ↑a = ⊤), motive a | false |
OrderEmbedding.locallyFiniteOrder._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder β] (f : α ↪o β)
(a b x : α), x ∈ (Finset.Ico (f a) (f b)).preimage ⇑f ⋯ ↔ a ≤ x ∧ x < b | false |
Std.DTreeMap.Internal.Impl.getKeyGT.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α) (x : Std.DTreeMap.Internal.Impl α β)
(x_1 : x.Ordered) (x_2 : ∃ a ∈ x, compare a k = Ordering.gt),
Std.DTreeMap.Internal.Impl.getKeyGT k x x_1 x_2 =
match x, x_1, x_2 with
| Std.DTreeMap.Internal.Impl.leaf, x, he => ⋯.elim
... | true |
Matrix.submatrixEquivInvertibleEquivInvertible._proof_2 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u_1} {n : Type u_3} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] (A : Matrix m m α) (e₁ e₂ : n ≃ m) (x : Invertible A),
A.invertibleOfSubmatrixEquivInvertible e₁ e₂ = x | false |
CategoryTheory.Functor.instSmallColimitType | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] [Small.{u, v} J] (F : CategoryTheory.Functor J (Type u)),
Small.{u, max u v} F.ColimitType | true |
Lean.Doc.Data.instReprSyntax.repr | Lean.Elab.DocString.Builtin | Lean.Doc.Data.Syntax → ℕ → Std.Format | true |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq._proof_2 | Std.Time.Time.PlainTime | ∀ (a : Std.Time.Hour.Ordinal) (a_1 : Std.Time.Minute.Ordinal) (a_2 : Std.Time.Second.Ordinal true)
(a_3 b : Std.Time.Nanosecond.Ordinal),
¬a_3 = b →
{ hour := a, minute := a_1, second := a_2, nanosecond := a_3 } =
{ hour := a, minute := a_1, second := a_2, nanosecond := b } →
False | false |
Lean.SubExpr.GoalsLocation.ctorIdx | Lean.SubExpr | Lean.SubExpr.GoalsLocation → ℕ | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.values.eq_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v}, Std.Internal.List.values [] = [] | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop._simp_6 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∀ (a : α), p a) = True | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toList_ric_eq_zero._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, n < i → i ≤ n → False | false |
SimplicialObject.Splitting.IndexSet.instEpiSimplexCategoryE | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ : SimplexCategoryᵒᵖ} (A : SimplicialObject.Splitting.IndexSet Δ), CategoryTheory.Epi A.e | true |
SeparationQuotient.instRightDistribClass | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Mul R] [inst_2 : Add R] [RightDistribClass R]
[inst_4 : ContinuousMul R] [inst_5 : ContinuousAdd R], RightDistribClass (SeparationQuotient R) | true |
Lean.Widget.InteractiveGoals.mk.injEq | Lean.Widget.InteractiveGoal | ∀ (goals goals_1 : Array Lean.Widget.InteractiveGoal), ({ goals := goals } = { goals := goals_1 }) = (goals = goals_1) | true |
Primrec.list_map | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{f : α → List β} {g : α → β → σ}, Primrec f → Primrec₂ g → Primrec fun a => List.map (g a) (f a) | true |
Nat.toSuperDigits | Init.Data.Repr | ℕ → List Char | true |
Matrix.toMvPolynomial_zero | Mathlib.Algebra.Module.LinearMap.Polynomial | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : CommSemiring R], Matrix.toMvPolynomial 0 = 0 | true |
LinearEquiv.symm_comp_eq | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M₁ : Type u_8} {M₂ : Type u_9} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ... | true |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.InvariantUse.stateArgs | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | Lean.Elab.Tactic.Do.InvariantUse✝ → Array Lean.Expr | true |
Lean.instBEqRecursorRule | Lean.Declaration | BEq Lean.RecursorRule | true |
CommMonCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.MonCat.Basic | {A B : CommMonCat} → A.Hom B → ℕ | false |
Polynomial.reverse_X_pow_mul | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (n : ℕ), (Polynomial.X ^ n * p).reverse = p.reverse | true |
Lean.Elab.Do.ControlLifter.noConfusion | Lean.Elab.Do.Control | {P : Sort u} → {t t' : Lean.Elab.Do.ControlLifter} → t = t' → Lean.Elab.Do.ControlLifter.noConfusionType P t t' | false |
Lean.Meta.Sym.ApplyResult.recOn | Lean.Meta.Sym.Apply | {motive : Lean.Meta.Sym.ApplyResult → Sort u} →
(t : Lean.Meta.Sym.ApplyResult) →
motive Lean.Meta.Sym.ApplyResult.failed →
((mvarIds : List Lean.MVarId) → motive (Lean.Meta.Sym.ApplyResult.goals mvarIds)) → motive t | false |
AddActionHom.congr_fun | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : VAdd M X] {Y : Type u_6} [inst_1 : VAdd N Y]
{f g : X →ₑ[φ] Y}, f = g → ∀ (x : X), f x = g x | true |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.elabSetOption | Lean.Elab.Tactic.Grind.BuiltinTactic | Lean.Elab.Tactic.Grind.GrindTactic | true |
HomogeneousIdeal.eq_bot_iff | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] (I : HomogeneousIdeal 𝒜),
I = ⊥ ↔ I.toIdeal = ⊥ | true |
monoidHomSlashAction._proof_4 | Mathlib.NumberTheory.ModularForms.SlashActions | ∀ {β : Type u_2} {G : Type u_3} {H : Type u_4} {α : Type u_1} [inst : Monoid G] [inst_1 : AddMonoid α]
[inst_2 : Monoid H] [inst_3 : SlashAction β G α] (h : H →* G) (x : β) (g : H) (x_1 x_2 : α),
SlashAction.map x (h g) (x_1 + x_2) = SlashAction.map x (h g) x_1 + SlashAction.map x (h g) x_2 | false |
AffineSubspace.mk | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] →
(carrier : Set P) →
(∀ (c : k) {p₁ p₂ p₃ : P},
p₁ ∈ carrier → p₂ ∈ carrier → p₃ ... | true |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.IsDershowitzMannaLT.trans._simp_1_3 | Mathlib.Data.Multiset.DershowitzManna | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | false |
CategoryTheory.AddMon.trivial_X | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
(CategoryTheory.AddMon.trivial C).X = CategoryTheory.MonoidalCategoryStruct.tensorUnit C | true |
Subalgebra.le_centralizer_centralizer | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Subalgebra R A},
s ≤ Subalgebra.centralizer R ↑(Subalgebra.centralizer R ↑s) | true |
multipliable_mabs_iff | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommGroup α] [inst_1 : LinearOrder α] [IsOrderedMonoid α]
[inst_3 : UniformSpace α] [IsUniformGroup α] [CompleteSpace α] {f : ι → α},
(Multipliable fun x => |f x|ₘ) ↔ Multipliable f | true |
equivTangentBundleProd_apply | Mathlib.Geometry.Manifold.ContMDiffMFDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_4)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
CategoryTheory.LiftableCone.noConfusionType | Mathlib.CategoryTheory.Limits.Creates | Sort u →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryThe... | false |
CocompactMap.coe_id | Mathlib.Topology.ContinuousMap.CocompactMap | ∀ (α : Type u_1) [inst : TopologicalSpace α], ⇑(CocompactMap.id α) = id | true |
Lean.Elab.Term.ExtractMonadResult.mk.sizeOf_spec | Lean.Elab.Do.Legacy | ∀ (m returnType expectedType : Lean.Expr),
sizeOf { m := m, returnType := returnType, expectedType := expectedType } =
1 + sizeOf m + sizeOf returnType + sizeOf expectedType | true |
Topology.IsCoinducing.rec | Mathlib.Topology.Defs.Induced | {X : Type u_1} →
{Y : Type u_2} →
[tX : TopologicalSpace X] →
[tY : TopologicalSpace Y] →
{f : X → Y} →
{motive : Topology.IsCoinducing f → Sort u} →
((eq_coinduced : tY = TopologicalSpace.coinduced f tX) → motive ⋯) →
(t : Topology.IsCoinducing f) → motive t | false |
rieszContentAux._proof_2 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ContinuousConstSMul NNReal NNReal | false |
Std.Do.SPred.Tactic.IsAnd.recOn | Std.Do.SPred.DerivedLaws | {σs : List (Type u)} →
{P Q₁ Q₂ : Std.Do.SPred σs} →
{motive : Std.Do.SPred.Tactic.IsAnd P Q₁ Q₂ → Sort u_1} →
(t : Std.Do.SPred.Tactic.IsAnd P Q₁ Q₂) → ((to_and : P ⊣⊢ₛ Q₁ ∧ Q₂) → motive ⋯) → motive t | false |
Order.Coframe.MinimalAxioms.ctorIdx | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → Order.Coframe.MinimalAxioms α → ℕ | false |
UInt32.right_le_or | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, b ≤ a ||| b | true |
MulOpposite.instAddCommMonoid._proof_3 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α] (x : αᵐᵒᵖ) (x_1 : ℕ), MulOpposite.unop (x_1 • x) = MulOpposite.unop (x_1 • x) | false |
DiscreteQuotient._sizeOf_inst | Mathlib.Topology.DiscreteQuotient | (X : Type u_5) → {inst : TopologicalSpace X} → [SizeOf X] → SizeOf (DiscreteQuotient X) | false |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.of_maxLiteral_eq_some'._simp_1_2 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {a : α} [inst : Max α] [inst_1 : LE α] {xs : Array α} [Std.IsLinearOrder α] [Std.LawfulOrderMax α],
(xs.max? = some a) = (a ∈ xs ∧ ∀ b ∈ xs, b ≤ a) | false |
Int64.ofIntLE_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 64), Int64.ofIntLE n.toInt ⋯ ⋯ = Int64.ofBitVec n | true |
Mathlib.Tactic.BicategoryLike.CoherenceHom.mk | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → Lean.Expr → Lean.Expr → Mathlib.Tactic.BicategoryLike.CoherenceHom | true |
_private.Lean.ResolveName.0.Lean.ResolveName.resolveNamespaceUsingScope?.match_1 | Lean.ResolveName | (motive : Lean.Name → Sort u_1) →
(ns : Lean.Name) →
((p : Lean.Name) → (str : String) → motive (p.str str)) →
(Unit → motive Lean.Name.anonymous) → ((x : Lean.Name) → motive x) → motive ns | false |
LinearIsometry.mk | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{E : Type u_11} →
{E₂ : Type u_12} →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup E₂] →
[inst_4 : Modul... | true |
RootPairing.EmbeddedG2.pairingIn_long_short | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {inst : CommRing R} {inst_1 : AddCommGroup M}
{inst_2 : Module R M} {inst_3 : AddCommGroup N} {inst_4 : Module R N} {P : RootPairing ι R M N} [self : P.EmbeddedG2],
P.pairingIn ℤ (RootPairing.EmbeddedG2.long P) (RootPairing.EmbeddedG2.short P) = -3 | true |
EuclideanSpace.restrict₂._proof_5 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι' : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {I J : Finset ι'} (hIJ : I ⊆ J),
Continuous fun x => WithLp.toLp 2 (Finset.restrict₂ hIJ x.ofLp) | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.X._default | Std.Time.Format.Basic | Option Std.Time.TimeZone.Offset | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.instanceStub._sparseCasesOn_7 | Batteries.CodeAction.Misc | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
ULift.nonUnitalNormedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : NonUnitalNormedCommRing α] {x y : ULift.{u_1, u_2} α}, dist x y = 0 → x = y | false |
conditionallyCompleteLatticeOfLatticeOfsSup._proof_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [H1 : Lattice α] (a b : α), ∃ x, x ∈ upperBounds {a, b} | false |
Nat.mul_lt_mul_of_lt_of_le | Init.Data.Nat.Lemmas | ∀ {a c b d : ℕ}, a < c → b ≤ d → 0 < d → a * b < c * d | true |
List.sortedGE_insertionSort | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : LinearOrder α], (List.insertionSort (fun x1 x2 => x1 ≥ x2) l).SortedGE | true |
AddEquiv.ofLeftInverse'_apply | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) {g : N → M}
(h : Function.LeftInverse g ⇑f) (a : M), (AddEquiv.ofLeftInverse' f h) a = f.mrangeRestrict a | true |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod.congr_simp | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K} {p : ℕ} [inst_1 : Fact (Nat.Prime p)]
[inst_2 : NumberField K] (hp : ¬p ∣ RingOfIntegers.exponent θ),
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod hp = NumberField.Ideal.primesOverSpanEquivMonicFactorsMod hp | true |
IsCompact.mem_inf_nhdsSet_of_forall | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {K : Set X} {l : Filter X} {s : Set X},
IsCompact K → (∀ y ∈ K, s ∈ l ⊓ nhds y) → s ∈ l ⊓ nhdsSet K | true |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.go₁.match_1.eq_2 | Batteries.Data.String.Lemmas | ∀ (motive : List Char → String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → Sort u_1) (c : Char) (cs : List Char)
(i b e : String.Pos.Raw) (h_1 : (x x_1 x_2 : String.Pos.Raw) → motive [] x x_1 x_2)
(h_2 :
(s : List Char) → (c : Char) → (cs : List Char) → s = c :: cs → (i b e : String.Pos.Raw) → motive (c :: cs) ... | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.L1.norm_eq_integral_norm._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | (1 = ⊤) = False | false |
CStarMatrix.one_apply_eq | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_2} {A : Type u_5} [inst : DecidableEq n] [inst_1 : Zero A] [inst_2 : One A] (i : n), 1 i i = 1 | true |
Lean.Elab.TacticInfo | Lean.Elab.InfoTree.Types | Type | true |
ContinuousMap.instAddGroupOfIsTopologicalAddGroup._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup β]
[inst_3 : IsTopologicalAddGroup β] (f g : C(α, β)), ⇑(f + g) = ⇑f + ⇑g | false |
CategoryTheory.Comonad.HasEqualizerOfIsCosplitPair.recOn | Mathlib.CategoryTheory.Monad.Comonadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Comonad.HasEqualizerOfIsCosplitPair F → Sort u} →
(t : CategoryTheory.Comonad.HasEqualizerOf... | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.rayleighQuotient_le_of_mem_resolventSet._proof_1_6 | Mathlib.Analysis.InnerProductSpace.Rayleigh | (1 + 1).AtLeastTwo | false |
Std.Tactic.BVDecide.BVExpr.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : (a : ℕ) → Std.Tactic.BVDecide.BVExpr a → Sort u} →
({w : ℕ} → (idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx)) →
({w : ℕ} → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val)) →
({w : ℕ} →
(start len : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) →
... | false |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_add_ofDigits_eq_ofDigits_zipWith_of_length_eq._simp_1_1 | Mathlib.Data.Nat.Digits.Defs | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Std.DTreeMap.get?_ofList_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Std.LawfulEqCmp cmp]
[inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List ((a : α) × β a)} {k : α},
(List.map Sigma.fst l).contains k = false → (Std.DTreeMap.ofList l cmp).get? k = none | true |
SignType.enumList | Mathlib.Data.Sign.Defs | List SignType | true |
nilpotent_center_quotient_ind | Mathlib.GroupTheory.Nilpotent | ∀ {P : (G : Type u_2) → [inst : Group G] → [Group.IsNilpotent G] → Prop} (G : Type u_2) [inst : Group G]
[inst_1 : Group.IsNilpotent G],
(∀ (G : Type u_2) [inst : Group G] [inst_2 : Subsingleton G], P G) →
(∀ (G : Type u_2) [inst : Group G] [inst_2 : Group.IsNilpotent G], P (G ⧸ Subgroup.center G) → P G) → P G | true |
Lean.Doc.SuggestionMode.noConfusion | Lean.Elab.DocString | {P : Sort v✝} → {x y : Lean.Doc.SuggestionMode} → x = y → Lean.Doc.SuggestionMode.noConfusionType P x y | false |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.findSuffixWithPrefix | Lean.Elab.BuiltinCommand | Lean.Name → Lean.Name → Option Lean.Name | true |
HahnSeries.isWF_support._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R), x.support.IsWF = True | false |
Ordnode.balance_eq_balance' | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {l : Ordnode α} {x : α} {r : Ordnode α},
l.Balanced → r.Balanced → l.Sized → r.Sized → l.balance x r = l.balance' x r | true |
Valuation.one_apply_def | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] [inst_2 : Nontrivial R]
[inst_3 : NoZeroDivisors R] [inst_4 : DecidablePred fun x => x = 0] (x : R), 1 x = if x = 0 then 0 else 1 | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c : Lean.Meta.Grind.Arith.Cutsat.CooperSplit),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₂ c) = 1 + sizeOf c | true |
CategoryTheory.InducedCategory.homLinearEquiv._proof_2 | Mathlib.CategoryTheory.Linear.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
{F : D → C} {X Y : CategoryTheory.InducedCategory C F} (x y : X ⟶ Y),
CategoryTheory.InducedCategory.homAddEquiv.toFun (x + y) =
CategoryTheory.InducedCategory.homAddEquiv.toFun x + CategoryTheo... | false |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.mul_le_addHaar_image_of_lt_det._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
_private.Lean.Meta.Sorry.0.Lean.Meta.SorryLabelView.encode._sparseCasesOn_1 | Lean.Meta.Sorry | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
List.Vector.tail_map | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} {β : Type u_6} (v : List.Vector α (n + 1)) (f : α → β),
(List.Vector.map f v).tail = List.Vector.map f v.tail | true |
AddUnits.embedding_val_mk | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_4} [inst : SubtractionMonoid M] [inst_1 : TopologicalSpace M],
ContinuousOn Neg.neg {x | IsAddUnit x} → Topology.IsEmbedding AddUnits.val | true |
Lean.Parser.Term.doNested._regBuiltin.Lean.Parser.Term.doNested.declRange_3 | Lean.Parser.Do | IO Unit | false |
SimpleGraph.CompleteBipartiteGraph.bicoloring._proof_1 | Mathlib.Combinatorics.SimpleGraph.Coloring.VertexColoring | ∀ (V : Type u_1) (W : Type u_2) {v w : V ⊕ W},
(completeBipartiteGraph V W).Adj v w → (fun v => v.isRight) v ≠ (fun v => v.isRight) w | false |
SeparationQuotient.instModuleFinite | Mathlib.Topology.Algebra.SeparationQuotient.FiniteDimensional | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Finite R M]
[inst_4 : TopologicalSpace M] [inst_5 : ContinuousAdd M] [inst_6 : ContinuousConstSMul R M],
Module.Finite R (SeparationQuotient M) | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Sigma.0.Finset.sum_comm'.match_1_5 | Mathlib.Algebra.BigOperators.Group.Finset.Sigma | ∀ {α : Type u_2} {γ : Type u_1} (motive : γ × α → Prop) (x : γ × α), (∀ (x : γ) (y : α), motive (x, y)) → motive x | false |
QuaternionAlgebra.Basis.mk.inj | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {inst : CommRing R} {inst_1 : Ring A} {inst_2 : Algebra R A} {c₁ c₂ c₃ : R} {i j k : A}
{i_mul_i : i * i = c₁ • 1 + c₂ • i} {j_mul_j : j * j = c₃ • 1} {i_mul_j : i * j = k} {j_mul_i : j * i = c₂ • j - k}
{i_1 j_1 k_1 : A} {i_mul_i_1 : i_1 * i_1 = c₁ • 1 + c₂ • i_1} {j_mul_j_1 : j_1 *... | true |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.Submodule.le_traceDual_iff_map_le_one._simp_1_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | false |
CategoryTheory.Oplax.OplaxTrans.Modification.vcomp._proof_2 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ ι : F ⟶ G} (Γ : CategoryTheory.Oplax.OplaxTrans.Modification η θ)
(Δ : CategoryTheory.Oplax.OplaxTrans.Modification θ ι) {a b : B} (f : a ⟶ b),
CategoryTheory.Ca... | false |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.checkBlocklist.match_3 | Mathlib.Tactic.Linter.DirectoryDependency | (motive : Option (Lean.Name × Lean.Name) → Sort u_1) →
(x : Option (Lean.Name × Lean.Name)) →
((n₁ n₂ : Lean.Name) → motive (some (n₁, n₂))) → (Unit → motive none) → motive x | false |
EReal.preimage_coe_Iio | Mathlib.Data.EReal.Basic | ∀ (y : ℝ), Real.toEReal ⁻¹' Set.Iio ↑y = Set.Iio y | true |
CategoryTheory.MonoOver.image._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [CategoryTheory.Limits.HasImages C]
(f : CategoryTheory.Over X), CategoryTheory.Limits.HasImage f.hom | false |
Set.Iio_True | Mathlib.Order.Interval.Set.Basic | Set.Iio True = {False} | true |
isStrictOrderConnected_of_isStrictTotalOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} {r : α → α → Prop} [IsStrictTotalOrder α r], IsOrderConnected α r | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.