name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.choose_eq_asc_factorial_div_factorial | Mathlib.Data.Nat.Choose.Basic | ∀ (n k : ℕ), (n + k).choose k = (n + 1).ascFactorial k / k.factorial | null | true |
MeasurableSpace.DynkinSystem.ext_iff | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {d₁ d₂ : MeasurableSpace.DynkinSystem α}, d₁ = d₂ ↔ ∀ (s : Set α), d₁.Has s ↔ d₂.Has s | null | true |
MvPFunctor.wRec | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} →
(P : MvPFunctor.{u} (n + 1)) →
{α : TypeVec.{u} n} →
{C : Sort u_1} → ((a : P.A) → (P.drop.B a).Arrow α → (P.last.B a → P.W α) → (P.last.B a → C) → C) → P.W α → C | Recursor for `W` | true |
IsLocalRing.instCommRingResidueField._proof_12 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R] (a b : IsLocalRing.ResidueField R), a + b = b + a | null | false |
_aux_Mathlib_Data_Finsupp_Defs___unexpand_Finsupp_1 | Mathlib.Data.Finsupp.Defs | Lean.PrettyPrinter.Unexpander | null | false |
NonUnitalRingHom.coe_mul | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} [inst : NonUnitalNonAssocSemiring α] (f g : α →ₙ+* α), ⇑(f * g) = ⇑f ∘ ⇑g | null | true |
instDecidableEqExcept_batteries.decEq | Batteries.Data.Except | {ε : Type u_1} → {α : Type u_2} → [DecidableEq ε] → [DecidableEq α] → (x x_1 : Except ε α) → Decidable (x = x_1) | null | true |
NonUnitalSubsemiring.mem_carrier | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {s : NonUnitalSubsemiring R} {x : R}, x ∈ s.carrier ↔ x ∈ s | null | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.getTag?._sparseCasesOn_1 | Lean.Data.Json.FromToJson.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((s : String) → motive_1 (Lean.Json.str s)) →
((kvPairs : Std.TreeMap.Raw String Lean.Json compare) → motive_1 (Lean.Json.obj kvPairs)) →
(Nat.hasNotBit 40 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
CStarAlgebra.isStrictlyPositive_iff_isSelfAdjoint_and_spectrum_pos | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[StarOrderedRing A] [inst_5 : Algebra ℝ A] [ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [NonnegSpectrumClass ℝ A]
[IsSemitopologicalRing A] [T2Space A] {a : A}, IsStrictlyPositive a ↔ IsSelfAdjoint a ∧... | null | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.findMin.match_1 | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{n : ℕ} →
(motive : (s : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.WF le n s → Sort u_2) →
(s : Batteries.BinomialHeap.Imp.Heap α) →
(h : Batteries.BinomialHeap.Imp.Heap.WF le n s) →
((h : Batteries.BinomialHeap.... | null | false |
Lean.Grind.Linarith.instBEqExpr.beq._sparseCasesOn_2 | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} →
(t : Lean.Grind.Linarith.Expr) →
((i : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var i)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Topology.LocallyConstant.Basic.0.LocallyConstant.piecewise'._simp_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.δ_descCochain._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {m : ℤ}, m + 1 + 1 = m + 2 | null | false |
Complex.tan_eq_one_sub_tan_half_sq_div_one_add_tan_half_sq | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ (x : ℂ), Complex.tan x = 2 * Complex.tan (x / 2) / (1 - Complex.tan (x / 2) ^ 2) | null | true |
CategoryTheory.StructuredArrow.prodEquivalence_inverse | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C' : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C'] {D' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D'] (S : D) (S' : D') (T : CategoryTheory.Functor C D)
(T' : CategoryTheor... | null | true |
Std.IterM.Equiv.forIn_eq | Std.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α₁ α₂ β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α₁ m β]
[inst_1 : Std.Iterator α₂ m β] [Std.Iterators.Finite α₁ m] [Std.Iterators.Finite α₂ m] [inst_4 : Monad m]
[inst_5 : LawfulMonad m] [inst_6 : Monad n] [LawfulMonad n] [inst_8 : Std.IteratorLoop α₁ m n]
[Std.LawfulIte... | null | true |
Lean.Meta.Sym.Arith.State.recOn | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.State → Sort u} →
(t : Lean.Meta.Sym.Arith.State) →
((exp : ℕ) →
(rings : Array Lean.Meta.Sym.Arith.CommRing) →
(semirings : Array Lean.Meta.Sym.Arith.CommSemiring) →
(ncRings : Array Lean.Meta.Sym.Arith.Ring) →
(ncSemirings : Array Lean.Me... | null | false |
PEquiv.refl._proof_1 | Mathlib.Basic.PEquiv | ∀ (α : Type u_1) (x x_1 : α), some x_1 = some x ↔ some x = some x_1 | null | false |
HomotopicalAlgebra.Precylinder.i₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {A : C} → (self : HomotopicalAlgebra.Precylinder A) → A ⟶ self.I | the second "inclusion" in the (pre)cylinder | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.capacity | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded.State✝ α → ℕ | The capacity of the buffer space.
| true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_eq_Ioc_iff._proof_1_4 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α}, b ≤ d ∧ c ≤ a → d ≤ b ∧ a ≤ c → a = c ∧ b = d | null | false |
Std.DTreeMap.Const.getKey_modify_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp}
[Inhabited α] {k : α} {f : β → β} {hc : k ∈ Std.DTreeMap.Const.modify t k f},
(Std.DTreeMap.Const.modify t k f).getKey k hc = k | null | true |
CategoryTheory.CartesianMonoidalCategory.liftEquiv._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{T X Y : C},
Function.LeftInverse
(fun f =>
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.SemiCartesianMonoidalCategory.fst X Y),
CategoryTheory.CategoryStruct.comp f (Categ... | null | false |
ULift.instLawfulApplicative_mathlib | Mathlib.Control.ULift | LawfulApplicative ULift.{u_2, u_1} | null | true |
WeierstrassCurve.toShortNFOfCharThree_a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [inst_1 : CharP R 3],
(W.toShortNFOfCharThree • W).a₂ = W.b₂ | null | true |
Nat.shiftLeft_zero | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, n <<< 0 = n | null | true |
Std.TreeMap.Raw.minKey?_eq_none_iff._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.minKey? = none) = (t.isEmpty = true) | null | false |
Submodule.projectionL_apply_eq_zero_iff | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : Submodule R M} (h : Submodule.IsTopCompl p q) {x : M}, (p.projectionL q h) x = 0 ↔ x ∈ q | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.instNonemptyUnbounded | Std.Sync.Channel | ∀ {α : Type}, Nonempty (Std.CloseableChannel.Unbounded✝ α) | null | true |
Std.TreeMap.Raw.isSome_apply_of_mem_filterMap | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}
[inst : Std.TransCmp cmp] {f : α → β → Option γ} {k : α} (h : t.WF) (h' : k ∈ Std.TreeMap.Raw.filterMap f t),
(f (t.getKey k ⋯) t[k]).isSome = true | null | true |
MulEquiv.finite_left | Mathlib.Basic.Finite.Prod | ∀ {α : Type u_3} {β : Type u_4} [inst : Mul α] [inst_1 : Mul β] [Finite α], Finite (α ≃* β) | null | true |
QuotientAddGroup.comapMk'OrderIso._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [hn : N.Normal] (x : ↑(Set.Ici N)),
N ≤ AddSubgroup.comap (QuotientAddGroup.mk' N) (AddSubgroup.map (QuotientAddGroup.mk' N) ↑x) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
-↑(2 ^ (w + 1)) ≤ 2 * x.toInt →
2 * x.toInt < ↑(2 ^ (w + 1)) →
-↑(2 ^ (w + 1)) ≤ 2 * y.toInt → ¬x.toInt - y.toInt - ↑(2 ^ (w + 1)) < (↑(2 ^ (w + 1)) + 1) / 2 → False | null | false |
Vector.toList_insertIdx | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {x : α} (h : i ≤ n),
(xs.insertIdx i x h).toList = xs.toList.insertIdx i x | null | true |
CategoryTheory.MorphismProperty.inverseImage_iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(P : CategoryTheory.MorphismProperty D) (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y),
P.inverseImage F f = P (F.map f) | null | false |
Std.BundledIterM.mk.injEq | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {m : Type w → Type w'} {β : Type w} (α : Type w) (inst : Std.Iterator α m β) (iterator : Std.IterM m β) (α_1 : Type w)
(inst_1 : Std.Iterator α_1 m β) (iterator_1 : Std.IterM m β),
({ α := α, inst := inst, iterator := iterator } = { α := α_1, inst := inst_1, iterator := iterator_1 }) =
(α = α_1 ∧ inst ≍ inst_... | null | true |
IsInvariantSubring.coe_subtypeHom | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_1) [inst : Monoid M] {R' : Type u_2} [inst_1 : Ring R'] [inst_2 : MulSemiringAction M R'] (U : Subring R')
[inst_3 : IsInvariantSubring M U], ⇑(IsInvariantSubring.subtypeHom M U) = Subtype.val | null | true |
RingCon.instNonUnitalNonAssocRingQuotient._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (c : RingCon R) (a b c_1 : c.Quotient),
a * (b + c_1) = a * b + a * c_1 | null | false |
Fin.foldr_eq_foldrM | Init.Data.Fin.Fold | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → α → α) (x : α),
Fin.foldr n f x = (Fin.foldrM n (fun x1 x2 => pure (f x1 x2)) x).run | null | true |
CategoryTheory.Presheaf.instIsLeftKanExtensionFunctorOppositeTypeIdCompUliftYonedaOfPreservesColimitsOfSizeOfHasPointwiseLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) ℰ)
[CategoryTheory.Limits.PreservesColimitsOfSize.{v₁, max w u₁ v₁ v₂, max (max (max u₁ v₁) v₂) w, v₂,
max (ma... | null | true |
Lean.Elab.WF.isWfParam? | Lean.Elab.PreDefinition.WF.Preprocess | Lean.Expr → Option Lean.Expr | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk | Lean.Elab.DocString | Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)) →
Std.HashMap String (Lean.Doc.Ref✝ String) → Array Lean.Doc.DeferredCheck → Lean.Doc.InternalState | null | true |
CategoryTheory.sheafComposeNatTrans | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | The canonical natural transformation
`(whiskeringRight Cᵒᵖ A B).obj F ⋙ G₂ ⟶ G₁ ⋙ sheafCompose J F`
when `F : A ⥤ B` is such that `J.HasSheafCompose F`, and that `G₁` and `G₂` are
left adjoints to the forget functors `sheafToPresheaf`. | true |
Real.comap_exp_nhds_zero | Mathlib.Analysis.SpecialFunctions.Exp | Filter.comap Real.exp (nhds 0) = Filter.atBot | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.3297654570._hygCtx._hyg.2 | Lean.Elab.DocString | IO Unit | null | false |
CategoryTheory.Functor.LaxRightLinear.μᵣ_associativity_assoc | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_1} {D' : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} D}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} (F : CategoryTheory.Functor D D') {C : Type u_3}
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} {inst_3 : CategoryTheory.MonoidalCategory C}
{inst_4 : CategoryTheory.MonoidalCategory.Mo... | null | true |
Nat.finMulAntidiag_zero_right | Mathlib.Algebra.Order.Antidiag.Nat | ∀ (d : ℕ), d.finMulAntidiag 0 = ∅ | null | true |
ContinuousMap.HomotopyRel.pi | Mathlib.Topology.Homotopy.Product | {I : Type u_1} →
{A : Type u_2} →
{X : I → Type u_3} →
[inst : (i : I) → TopologicalSpace (X i)] →
[inst_1 : TopologicalSpace A] →
{f g : (i : I) → C(A, X i)} →
{S : Set A} →
((i : I) → (f i).HomotopyRel (g i) S) → (ContinuousMap.pi f).HomotopyRel (ContinuousMap.p... | The relative product homotopy of `homotopies` between functions `f` and `g` | true |
derangements.Equiv.RemoveNone.fiber_none | Mathlib.Combinatorics.Derangements.Basic | ∀ {α : Type u_1} [inst : DecidableEq α], derangements.Equiv.RemoveNone.fiber none = ∅ | null | true |
List.getLast_getLast_splitBy | Mathlib.Data.List.SplitBy | ∀ {α : Type u_1} (r : α → α → Bool) {l : List α} (hn : l ≠ []), ((List.splitBy r l).getLast ⋯).getLast ⋯ = l.getLast hn | null | true |
instAlgebraUniversalEnvelopingAlgebra | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → Algebra R (UniversalEnvelopingAlgebra R L) | null | true |
_private.Mathlib.CategoryTheory.Limits.MorphismProperty.0.CategoryTheory.CostructuredArrow.isClosedUnderColimitsOfShape.match_1_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} T] {A : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} A] {L : CategoryTheory.Functor A T} {J : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} J] {P : CategoryTheory.MorphismProperty T} (X : T)
(Y : CategoryTheory.CostructuredArrow L X)
... | null | false |
FiniteArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : FiniteArchimedeanClass M), c.closedBallAddSubgroup = FiniteArchimedeanClass.addSubgroup (UpperSet.Ici c) | null | true |
_private.Mathlib.MeasureTheory.Integral.Average.0.MeasureTheory.exists_setLAverage_le.match_1_1 | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f : α → ENNReal}
(motive : {x | x ∈ s ∧ ⨍⁻ (a : α) in s, f a ∂μ ≤ f x}.Nonempty → Prop)
(x : {x | x ∈ s ∧ ⨍⁻ (a : α) in s, f a ∂μ ≤ f x}.Nonempty),
(∀ (x : α) (hx : x ∈ s) (h : ⨍⁻ (a : α) in s, f a ∂μ ≤ f x), motive ⋯) → motive x | null | false |
ENNReal.nhdsGT_zero_neBot | Mathlib.Topology.Instances.ENNReal.Lemmas | (nhdsWithin 0 (Set.Ioi 0)).NeBot | null | true |
Algebra.Extension.H1Cotangent.equiv._proof_4 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {S : Type u_1} [inst : CommRing S], RingHomInvPair (RingHom.id S) (RingHom.id S) | null | false |
Std.HashMap.Raw.recOn | Std.Data.HashMap.Raw | {α : Type u} →
{β : Type v} →
{motive : Std.HashMap.Raw α β → Sort u_1} →
(t : Std.HashMap.Raw α β) → ((inner : Std.DHashMap.Raw α fun x => β) → motive { inner := inner }) → motive t | null | false |
CategoryTheory.ObjectProperty.prop_retractClosure_iff | Mathlib.CategoryTheory.ObjectProperty.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C) (X : C),
P.retractClosure X ↔ ∃ Y, ∃ (_ : P Y), Nonempty (CategoryTheory.Retract X Y) | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Basic.0.AlgebraicGeometry.HasAffineProperty.iff.match_1_1 | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {Q : AlgebraicGeometry.AffineTargetMorphismProperty}
(motive : AlgebraicGeometry.IsZariskiLocalAtTarget P ∧ Q = AlgebraicGeometry.AffineTargetMorphismProperty.of P → Prop)
(x : AlgebraicGeometry.IsZariskiLocalAtTarget P ∧ Q = AlgebraicGeometry.AffineT... | null | false |
Irreducible.isRoot_eq_bot_of_natDegree_ne_one | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} [IsDomain R], Irreducible p → p.natDegree ≠ 1 → p.IsRoot = ⊥ | null | true |
BitVec.clz_lt_iff_ne_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x.clz < ↑w ↔ x ≠ 0#w | The number of leading zeroes is strictly less than the bitwidth iff the bitvector is nonzero. | true |
Commute.invOf_left | Mathlib.Algebra.Group.Invertible.Basic | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible b], Commute b a → Commute (⅟b) a | null | true |
Option.get_congr | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α} {ho : o.isSome = true} (h : o = o'), o.get ho = o'.get ⋯ | null | true |
Lean.Expr.rat? | Mathlib.Lean.Expr.Rat | Lean.Expr → Option ℚ | Check if an expression is a "rational in normal form",
i.e. either an integer number in normal form,
or `n / d` where `n` is an integer in normal form, `d` is a natural number in normal form,
`d ≠ 1`, and `n` and `d` are coprime (in particular, we check that `(mkRat n d).den = d`).
If so returns the rational number.
| true |
Units.instDiv.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α],
Units.instDiv = { div := fun a b => { val := ↑a * ↑b⁻¹, inv := ↑b * ↑a⁻¹, val_inv := ⋯, inv_val := ⋯ } } | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitType._unsafe_rec | Lean.Meta.LetToHave | Lean.Expr → Lean.Meta.LetToHave.M✝ Lean.Meta.LetToHave.Result✝ | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt32.reduceBin.match_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | (motive : Option UInt32 → Sort u_1) →
(__x : Option UInt32) → ((m : UInt32) → motive (some m)) → ((x : Option UInt32) → motive x) → motive __x | null | false |
instMonadLiftT | Init.Prelude | (m : Type u_1 → Type u_2) → MonadLiftT m m | null | true |
Std.ExtHashMap.unitOfList_eq_empty_iff._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List α},
(Std.ExtHashMap.unitOfList l = ∅) = (l = []) | null | false |
Orientation.kahler._proof_5 | Mathlib.Analysis.InnerProductSpace.TwoDim | SMulCommClass ℝ ℝ ℂ | null | false |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.small_subsheafify_of_small._proof_1_7 | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
(hF : ∀ ⦃X : C⦄, ∀ R ∈ K.coverings X, CategoryTheory.Presieve.IsSheafFor F R)
(𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))) (h : ∀ (Z : C), Small.{max u_3 u_2, u_1} ↑(𝒮 Z))... | null | false |
_private.Mathlib.Analysis.Convex.Gauge.0.Convex.uniformContinuous_gauge.match_1_1 | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E}
(motive : (∃ K, LipschitzWith K (gauge s)) → Prop) (x : ∃ K, LipschitzWith K (gauge s)),
(∀ (_K : NNReal) (hK : LipschitzWith _K (gauge s)), motive ⋯) → motive x | null | false |
_private.Mathlib.Data.List.Basic.0.List.getLastI_eq_getLast?_getD._sparseCasesOn_1_1 | Mathlib.Data.List.Basic | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CochainComplex.mappingCone.inr_snd_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e : ℤ} (γ : CochainComplex.HomComplex.Cochain G K d) (he : 0 + d = e),
(CochainComplex.HomCompl... | null | true |
NNReal.isometry_coe | Mathlib.Topology.MetricSpace.Isometry | Isometry NNReal.toReal | null | true |
Sum.instPreorderSum._proof_3 | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (x x_1 x_2 : α ⊕ β),
Sum.LiftRel (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) x x_1 →
Sum.LiftRel (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) x_1 x_2 →
Sum.LiftRel (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) x x_2 | null | false |
DiscreteConvolution.AddConvolutionExistsAt.convolution_vadd | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {S : Type u_2} {E : Type u_3} {E' : Type u_4} [inst : AddMonoid M] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid E] [inst_3 : AddCommMonoid E'] [inst_4 : Module S E] [inst_5 : Module S E'] {F : Type u_8}
[inst_6 : AddCommMonoid F] [inst_7 : Module S F] [inst_8 : TopologicalSpace F] [ContinuousC... | null | true |
Std.IterM.toListRev_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toListRev = (fun x => List.filterMap f x) <$> it.toListRev | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.aux_tendsto_tsum._simp_1_7 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
Ring.krullDimLE_one_iff | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} [inst : CommSemiring R],
Ring.KrullDimLE 1 R ↔ ∀ (I : Ideal R), I.IsPrime → I ∈ minimalPrimes R ∨ I.IsMaximal | null | true |
DirectLimit.induction₃ | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[inst_2 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
{C : DirectLimit F f → DirectLimit F ... | null | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.drop_append._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} (tail : List α) (n : ℕ), ¬n - tail.length = n + 1 - (tail.length + 1) → False | null | false |
TopCat.pathEquiv_apply_apply | Mathlib.Topology.Homotopy.TopCat.Path | ∀ {X : TopCat} {x y : ↑X} (p : X.Path x y) (a : ↑unitInterval),
(TopCat.pathEquiv p) a = (TopCat.Hom.hom p.hom) (TopCat.I.homeomorph.symm a) | null | true |
CategoryTheory.Limits.isIso_limit_cone_parallelPair_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y} {c : CategoryTheory.Limits.Fork f g}
(h : CategoryTheory.Limits.IsLimit c) [CategoryTheory.Epi c.ι], CategoryTheory.IsIso c.ι | An equalizer that is an epimorphism is an isomorphism. | true |
FirstOrder.Language.Theory.IsMaximal | Mathlib.ModelTheory.Satisfiability | {L : FirstOrder.Language} → L.Theory → Prop | A theory is maximal when it is satisfiable and contains each sentence or its negation.
Maximal theories are complete. | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Defs.0.IntermediateField.sSup_toSubfield._simp_1_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Algebra.Ring.Parity.0.Nat.not_even_two_mul_add_one._proof_1_1 | Mathlib.Algebra.Ring.Parity | ∀ (n : ℕ), ¬Even (2 * n + 1) | null | false |
CFC.posPart_eq_zero_iff._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | Lean.Syntax | null | false |
Orientation.inner_mul_inner_add_areaForm_mul_areaForm | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (a x y : E),
inner ℝ a x * inner ℝ a y + (o.areaForm a) x * (o.areaForm a) y = ‖a‖ ^ 2 * inner ℝ x y | For vectors `a x y : E`, the identity `⟪a, x⟫ * ⟪a, y⟫ + ω a x * ω a y = ‖a‖ ^ 2 * ⟪x, y⟫`. | true |
Lean.Parser.Tactic.funInduction | Init.Tactics | Lean.ParserDescr | The `fun_induction` tactic is a convenience wrapper around the `induction` tactic to use the
functional induction principle.
The tactic invocation
```
fun_induction f x₁ ... xₙ y₁ ... yₘ
```
where `f` is a function defined by non-mutual structural or well-founded recursion, is equivalent to
```
induction y₁, ... yₘ us... | true |
NumberField.mixedEmbedding.logMap_real | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (c : ℝ), NumberField.mixedEmbedding.logMap (c • 1) = 0 | null | true |
MonoidAlgebra.mapAddEquiv._proof_5 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_1} {S : Type u_3} (M : Type u_2) [inst : Semiring R] [inst_1 : Semiring S] (e : R ≃+ S)
(x y : MonoidAlgebra R M), MonoidAlgebra.map (↑e) (x + y) = MonoidAlgebra.map (↑e) x + MonoidAlgebra.map (↑e) y | null | false |
Aesop.UnorderedArraySet.instForInOfMonad._private_1 | Aesop.Util.UnorderedArraySet | {α : Type u_2} →
[inst : BEq α] →
{m : Type u_1 → Type u_3} →
[Monad m] → {β : Type u_1} → Aesop.UnorderedArraySet α → β → (α → β → m (ForInStep β)) → m β | null | false |
add_eq_right_iff_le | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : IdemSemiring α] {a b : α}, a + b = b ↔ a ≤ b | null | true |
IsSelfNeg.of_negMemClass._simp_1 | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} {S : Type u_4} [inst : InvolutiveNeg G] [inst_1 : SetLike S G] [NegMemClass S G] (H : S),
IsSelfNeg ↑H = True | null | false |
Lean.Meta.Closure.MkValueTypeClosureResult.value | Lean.Meta.Closure | Lean.Meta.Closure.MkValueTypeClosureResult → Lean.Expr | null | true |
Fin.image_castLE_Ico | Mathlib.Order.Interval.Set.Fin | ∀ {m n : ℕ} (i j : Fin m) (h : m ≤ n), Fin.castLE h '' Set.Ico i j = Set.Ico (Fin.castLE h i) (Fin.castLE h j) | null | true |
Lean.collectLevelMVars | Lean.Util.CollectLevelMVars | Lean.CollectLevelMVars.State → Lean.Expr → Lean.CollectLevelMVars.State | Collects all universe level metavariables present in `e`.
Result is in `Lean.CollectLevelMVars.State.result`.
| true |
Qq.Impl._aux_Qq_AssertInstancesCommute___macroRules_Lean_Parser_Term_assert_2 | Qq.AssertInstancesCommute | Lean.Macro | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.