name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Basic.0.String.length_push._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, s.length = s.toList.length | false |
Equiv.addGroup._proof_2 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddGroup β] (x y : α), e (e.symm (e x + e y)) = e x + e y | false |
Std.Tactic.BVDecide.BVExpr.bitblast._proof_25 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w n : ℕ) (aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(lhs : aig_1.RefVec w),
aig.decls.size ≤ { aig := aig_1, vec := lhs }.aig.decls.size →
∀ (aig_2 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_2.RefVec n)
(hraig : aig_1.decls.size ≤ { aig := aig... | false |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.renderRewrites.renderSectionCore | Mathlib.Tactic.Widget.LibraryRewrite | Lean.Lsp.Range →
Lean.Server.FileWorker.EditableDocument →
Bool → Array Mathlib.Tactic.LibraryRewrite.RewriteInterface → ProofWidgets.Html | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State.IsExtensionBy.congr_simp | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} (state1 state1_1 : Std.Sat.AIG.toCNF.State✝ aig),
state1 = state1_1 →
∀ (state2 state2_1 : Std.Sat.AIG.toCNF.State✝ aig),
state2 = state2_1 →
∀ (new new_1 : ℕ) (e_new : new = new_1) (hnew : new < aig.decls.size),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state1 state2 ... | true |
IsOrderedCancelSMul.mk._flat_ctor | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} [inst : LE G] [inst_1 : LE P] [inst_2 : SMul G P],
(∀ (a b : P), a ≤ b → ∀ (c : G), c • a ≤ c • b) →
(∀ (c d : G), c ≤ d → ∀ (a : P), c • a ≤ d • a) →
(∀ (a : G) (b c : P), a • b ≤ a • c → b ≤ c) →
(∀ (a b : G) (c : P), a • c ≤ b • c → a ≤ b) → IsOrderedCancelSMul G P | false |
_private.Std.Internal.Async.DNS.0.Std.Internal.IO.Async.DNS.getAddrInfo.match_1 | Std.Internal.Async.DNS | (motive : Option Std.Net.AddressFamily → Sort u_1) →
(addrFamily : Option Std.Net.AddressFamily) →
(Unit → motive none) →
(Unit → motive (some Std.Net.AddressFamily.ipv4)) →
(Unit → motive (some Std.Net.AddressFamily.ipv6)) → motive addrFamily | false |
CategoryTheory.Abelian.SpectralObject.isZero₁_of_isThirdQuadrant | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Y : CategoryTheory.Abelian.SpectralObject C EInt) [Y.IsThirdQuadrant] (i j : EInt) (hij : i ≤ j),
WithBotTop.coe 0 < i →
∀ (n : ℤ),
CategoryTheory.Limits.IsZero ((Y.H n).obj (CategoryTheory.ComposableArrows... | true |
Order.IsSuccLimit.not_isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α], Order.IsSuccLimit a → ¬IsMin a | true |
NonUnitalStarAlgebra.adjoin_eq_starClosure_adjoin | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (s : Set A), NonUnitalStarAlgebra.adjoin R s = (NonUnitalAlgebra.adjoin R s).st... | true |
Coalgebra.TensorProduct.assoc_symm_tmul | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ {R : Type u_5} {S : Type u_6} {M : Type u_7} {N : Type u_8} {P : Type u_9} [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module R N] [inst_8 : Module R P] [inst_9 : Module S ... | true |
Lean.ReducibilityHints.lt | Lean.Declaration | Lean.ReducibilityHints → Lean.ReducibilityHints → Bool | true |
CategoryTheory.Abelian.Ext.linearEquiv₀._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {R : Type u_4} [inst : Ring R] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] [inst_4 : CategoryTheory.HasExt C] {X Y : C}
(m : R) (x : CategoryTheory.Abelian.Ext X Y 0),
CategoryTheory.Abelian.Ext.addEquiv₀.toFun (m • x) =... | false |
Polynomial.natDegree_multiset_prod | Mathlib.Algebra.Polynomial.BigOperators | ∀ {R : Type u} [inst : CommSemiring R] [NoZeroDivisors R] (t : Multiset (Polynomial R)),
0 ∉ t → t.prod.natDegree = (Multiset.map Polynomial.natDegree t).sum | true |
CategoryTheory.Endofunctor.Coalgebra.Hom.comp | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C C} →
{V₀ V₁ V₂ : CategoryTheory.Endofunctor.Coalgebra F} → V₀.Hom V₁ → V₁.Hom V₂ → V₀.Hom V₂ | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.brecOn_3 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.C... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.maxKey?_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Multiset.card_pos_iff_exists_mem | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α}, 0 < s.card ↔ ∃ a, a ∈ s | true |
FreeMagma.traverse_mul' | Mathlib.Algebra.Free | ∀ {α β : Type u} {m : Type u → Type u} [inst : Applicative m] (F : α → m β),
Function.comp (traverse F) ∘ HMul.hMul = fun x y => (fun x1 x2 => x1 * x2) <$> traverse F x <*> traverse F y | true |
Lean.Meta.isLevelDefEqAuxImpl | Lean.Meta.LevelDefEq | Lean.Level → Lean.Level → Lean.MetaM Bool | true |
Order.not_isSuccPrelimit_iff_exists_covBy | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LT α] (a : α), ¬Order.IsSuccPrelimit a ↔ ∃ b, b ⋖ a | true |
CategoryTheory.SmallObject.SuccStruct.ofCocone.map._proof_5 | Mathlib.CategoryTheory.SmallObject.Iteration.FunctorOfCocone | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J}, ∀ i₂ ≤ j, ¬i₂ < j → i₂ = j | false |
Std.TreeMap.Raw.mem_keysArray | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.LawfulEqCmp cmp]
[Std.TransCmp cmp], t.WF → ∀ {k : α}, k ∈ t.keysArray ↔ k ∈ t | true |
Equiv.Perm.SameCycle.extendDomain | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {β : Type u_3} {g : Equiv.Perm α} {x y : α} {p : β → Prop} [inst : DecidablePred p]
{f : α ≃ Subtype p}, g.SameCycle x y → (g.extendDomain f).SameCycle ↑(f x) ↑(f y) | true |
FirstOrder.Language.Theory.CompleteType.subset | Mathlib.ModelTheory.Types | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} (p : T.CompleteType α), (L.lhomWithConstants α).onTheory T ⊆ ↑p | true |
Std.TreeSet.Equiv.getLE_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{h' : ∃ a ∈ t₁, (cmp a k).isLE = true} (h : t₁.Equiv t₂), t₁.getLE k h' = t₂.getLE k ⋯ | true |
Lean.Meta.Context.mk.injEq | Lean.Meta.Basic | ∀ (keyedConfig : Lean.Meta.ConfigWithKey) (trackZetaDelta : Bool) (zetaDeltaSet : Lean.FVarIdSet)
(lctx : Lean.LocalContext) (localInstances : Lean.LocalInstances) (defEqCtx? : Option Lean.Meta.DefEqContext)
(synthPendingDepth : ℕ) (canUnfold? : Option (Lean.Meta.Config → Lean.ConstantInfo → Lean.CoreM Bool))
(un... | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.go | Init.Data.List.MinMaxIdx | {β : Type u_1} → {α : Type u_2} → [inst : LE β] → [DecidableLE β] → (α → β) → α → ℕ → ℕ → List α → ℕ | true |
Lean.Lsp.LeanDiagnosticTag.recOn | Lean.Data.Lsp.Diagnostics | {motive : Lean.Lsp.LeanDiagnosticTag → Sort u} →
(t : Lean.Lsp.LeanDiagnosticTag) →
motive Lean.Lsp.LeanDiagnosticTag.unsolvedGoals → motive Lean.Lsp.LeanDiagnosticTag.goalsAccomplished → motive t | false |
CategoryTheory.ComposableArrows.Precomp.map.eq_4 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f : X ⟶ F.left) (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1) (hij : ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩),
CategoryTheory.ComposableArrows.Precomp.map F f ⟨i.succ, hi⟩ ⟨j.succ, hj⟩ hij... | true |
Std.LawfulCmp.eq_lt_iff_lt | Batteries.Classes.Order | ∀ {α : Type u_1} {inst : LE α} {inst_1 : LT α} {cmp : α → α → Ordering} [self : Std.LawfulCmp cmp] {x y : α},
cmp x y = Ordering.lt ↔ x < y | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FlatMap.0.Std.Iter.toList_flatMapAfterM.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α₂ γ : Type u_1} {m : Type u_1 → Type u_2} (motive : Option (Std.IterM m γ) → Sort u_3) (h_1 : Unit → motive none)
(h_2 : (it₂ : Std.IterM m γ) → motive (some it₂)),
(match none with
| none => h_1 ()
| some it₂ => h_2 it₂) =
h_1 () | true |
CategoryTheory.Limits.zero_of_comp_mono | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y Z : C}
{f : X ⟶ Y} (g : Y ⟶ Z) [CategoryTheory.Mono g], CategoryTheory.CategoryStruct.comp f g = 0 → f = 0 | true |
Array.filterSepElems | Init.Meta.Defs | Array Lean.Syntax → (Lean.Syntax → Bool) → Array Lean.Syntax | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Formula___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Formula_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | Lean.Macro | false |
Lean.Grind.CommRing.eq_of_powerRevlex | Init.Grind.Ring.CommSolver | ∀ {k₁ k₂ : ℕ}, Lean.Grind.CommRing.powerRevlex k₁ k₂ = Ordering.eq → k₁ = k₂ | true |
Lean.Server.Watchdog.LogData.chan? | Lean.Server.Watchdog | Lean.Server.Watchdog.LogData → Option (Std.Channel Lean.Server.Watchdog.LogMsg) | true |
Vector.instNatModule._proof_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {n : ℕ} [inst : Lean.Grind.NatModule α] (x : Vector α n), 0 • x = 0 | false |
RingCon.coe_mul._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (c : RingCon R) (x y : R), ↑x * ↑y = ↑(x * y) | false |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.LinearMap.IsPositive.conj_adjoint._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E), T.IsPositive = (LinearMap.toContinuousLinearMap T).IsPositive | false |
_private.Std.Do.Triple.SpecLemmas.0.List.eq_of_range'_eq_append_cons._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m k n : ℕ}, (n + m = n + k) = (m = k) | false |
Turing.PartrecToTM2.Λ'.pred.inj | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {q₁ q₂ q₁_1 q₂_1 : Turing.PartrecToTM2.Λ'}, q₁.pred q₂ = q₁_1.pred q₂_1 → q₁ = q₁_1 ∧ q₂ = q₂_1 | true |
SupBotHom.subtypeVal._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {β : Type u_1} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {P : β → Prop} (Pbot : P ⊥)
(Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)), (SupHom.subtypeVal Psup).toFun ⊥ = ⊥ | false |
Aesop.RuleTacDescr.forwardMatches.elim | Aesop.RuleTac.Descr | {motive : Aesop.RuleTacDescr → Sort u} →
(t : Aesop.RuleTacDescr) →
t.ctorIdx = 10 → ((ms : Array Aesop.ForwardRuleMatch) → motive (Aesop.RuleTacDescr.forwardMatches ms)) → motive t | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.map._simp_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Affine R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsSca... | false |
CategoryTheory.Subfunctor.iSup_min | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)} {ι : Sort u_1}
(S : ι → CategoryTheory.Subfunctor F) (T : CategoryTheory.Subfunctor F), (⨆ i, S i) ⊓ T = ⨆ i, S i ⊓ T | true |
FirstOrder.Language.DefinableSet.coe_sdiff | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {A : Set M} {α : Type u₁} (s t : L.DefinableSet A α),
↑(s \ t) = ↑s \ ↑t | true |
_private.Mathlib.NumberTheory.ModularForms.Cusps.0.CongruenceSubgroup.strictPeriods_Gamma._simp_1_2 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {N : ℕ} {γ : Matrix.SpecialLinearGroup (Fin 2) ℤ},
(γ ∈ CongruenceSubgroup.Gamma N) = (↑(↑γ 0 0) = 1 ∧ ↑(↑γ 0 1) = 0 ∧ ↑(↑γ 1 0) = 0 ∧ ↑(↑γ 1 1) = 1) | false |
_private.Mathlib.Algebra.Category.CommBialgCat.0.CommBialgCat.mk._flat_ctor | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [commRing : CommRing carrier] → [bialgebra : Bialgebra R carrier] → CommBialgCat R | false |
iterate_frobenius | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] (p n : ℕ) [inst_1 : ExpChar R p] (x : R), (⇑(frobenius R p))^[n] x = x ^ p ^ n | true |
_private.Mathlib.Order.Filter.Prod.0.Filter.prod_mem_prod_iff.match_1_3 | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : Filter α} {g : Filter β}
(motive : (∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s ×ˢ t) → Prop) (x : ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ ×ˢ t₂ ⊆ s ×ˢ t),
(∀ (_s' : Set α) (hs' : _s' ∈ f) (_t' : Set β) (ht' : _t' ∈ g) (H : _s' ×ˢ _t' ⊆ s ×ˢ t), motive ⋯) → motive x | false |
FiberBundle.Prod.isInducing_diag | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_1} (F₁ : Type u_2) (E₁ : B → Type u_3) (F₂ : Type u_4) (E₂ : B → Type u_5)
[inst : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_1 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)],
Topology.IsInducing fun p => (⟨p.proj, p.snd.1⟩, ⟨p.proj, p.snd.2⟩) | true |
Std.DTreeMap.Raw.getKeyD_minKey? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {km fallback : α}, t.minKey? = some km → t.getKeyD km fallback = km | true |
Lean.Meta.Grind.Arith.Cutsat.ToIntThms.mk | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Option Lean.Expr → Option Lean.Expr → Option Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.Arith.Cutsat.ToIntThms | true |
MeasureTheory.HasFiniteIntegral.congr'_enorm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {ε' : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : ENorm ε'] {f : α → ε} {g : α → ε'},
MeasureTheory.HasFiniteIntegral f μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ₑ = ‖g a‖ₑ) → MeasureTheory.HasFiniteIntegral g μ | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isNonTrivialRegular.isSimple._unsafe_rec | Lean.Meta.ExprDefEq | Lean.Expr → Bool → Bool | false |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.Pos.Splits.toByteArray_eq_left._simp_1_2 | Init.Data.String.Lemmas.Splits | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | false |
HurwitzKernelBounds.F_nat | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ℕ → ℝ → ℝ → ℝ | true |
Lean.Compiler.LCNF.Closure.Context._sizeOf_1 | Lean.Compiler.LCNF.Closure | Lean.Compiler.LCNF.Closure.Context → ℕ | false |
«term_≡_[ZMOD_]» | Mathlib.Data.Int.ModEq | Lean.TrailingParserDescr | true |
Ideal.eq_jacobson_iff_notMem | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R}, I.jacobson = I ↔ ∀ x ∉ I, ∃ M, (I ≤ M ∧ M.IsMaximal) ∧ x ∉ M | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Code.instantiateValueLevelParams.instAlt._unsafe_rec | Lean.Compiler.LCNF.Basic | List Lean.Name →
List Lean.Level →
Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure | false |
Submonoid.LocalizationMap.exists_of_eq | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) {x y : M}, f x = f y → ∃ c, ↑c * x = ↑c * y | true |
TopCat.GlueData._sizeOf_inst | Mathlib.Topology.Gluing | SizeOf TopCat.GlueData | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.get!_insertIfNew._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
MeasurableSub.recOn | Mathlib.MeasureTheory.Group.Arithmetic | {G : Type u_2} →
[inst : MeasurableSpace G] →
[inst_1 : Sub G] →
{motive : MeasurableSub G → Sort u} →
(t : MeasurableSub G) →
((measurable_const_sub : ∀ (c : G), Measurable fun x => c - x) →
(measurable_sub_const : ∀ (c : G), Measurable fun x => x - c) → motive ⋯) →
... | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.fastUmulOverflow._proof_1_9 | Init.Data.BitVec.Bitblast | ∀ (w : ℕ) (x y : BitVec (w + 1 + 1)),
2 ^ (w + 1 + 1) ≤ x.toNat * y.toNat → 0 < 2 ^ (w + 1 + 1) → x.toNat * y.toNat = 0 → False | false |
ValuativeRel.mul_vlt_mul_iff_left | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y z : R}, 0 <ᵥ z → (x * z <ᵥ y * z ↔ x <ᵥ y) | true |
Filter.smul_filter_le_smul_filter | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f₁ f₂ : Filter β} {a : α}, f₁ ≤ f₂ → a • f₁ ≤ a • f₂ | true |
Lean.Meta.Grind.Arith.CommRing.Semiring.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (id : ℕ) (type : Lean.Expr) (u : Lean.Level) (semiringInst : Lean.Expr)
(addFn? mulFn? powFn? natCastFn? : Option Lean.Expr)
(denote : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.SemiringExpr)
(vars : Lean.PArray Lean.Expr) (varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing... | true |
_private.Mathlib.Data.Sum.Order.0.Sum.denselyOrdered.match_3 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] (motive : (a b : α ⊕ β) → a < b → Prop) (a b : α ⊕ β)
(h : a < b),
(∀ (val val_1 : α) (h : val < val_1), motive (Sum.inl val) (Sum.inl val_1) ⋯) →
(∀ (val val_1 : β) (h : val < val_1), motive (Sum.inr val) (Sum.inr val_1) ⋯) → motive a b h | false |
CategoryTheory.Limits.MultispanShape.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | (L : Type w) → (R : Type w') → (L → R) → (L → R) → CategoryTheory.Limits.MultispanShape | false |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinset.eq_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (α : Type w)
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C],
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinset C α =
{ obj := CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetObj,
map := fun {X Y} β => { app := fun ... | true |
Std.Sat.AIG.RefVec.countKnown.go._unary._proof_1 | Std.Sat.AIG.RefVec | ∀ {len : ℕ} (idx acc : ℕ),
idx < len →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun idx acc => len - idx) ⟨idx + 1, acc + 1⟩ ⟨idx, acc⟩ | false |
Std.DHashMap.Internal.Raw₀.Const.toListModel_insertListIfNewUnitₘ | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{m : Std.DHashMap.Internal.Raw₀ α fun x => Unit} {l : List α},
Std.DHashMap.Internal.Raw.WFImp ↑m →
(Std.DHashMap.Internal.toListModel (↑(Std.DHashMap.Internal.Raw₀.Const.insertListIfNewUnitₘ m l)).buckets).Perm
(Std.Inter... | true |
Finset.ssubset_insert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α}, a ∉ s → s ⊂ insert a s | true |
Real.cos_pos_of_le_one | Mathlib.Analysis.Complex.Trigonometric | ∀ {x : ℝ}, |x| ≤ 1 → 0 < Real.cos x | true |
AddMonCat.HasLimits.limitConeIsLimit._proof_4 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections]
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe (equivShrink ↑(F.comp (CategoryTheory.forget AddMonCat)).sections)
... | false |
Std.ExtTreeMap.getKey?_maxKeyD | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {fallback : α}, t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback) | true |
instIndiscreteTopology | Mathlib.Topology.Order | ∀ {α : Type u_1}, IndiscreteTopology α | true |
CategoryTheory.MorphismProperty.Comma.mapLeftEq_inv_app_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | true |
InfiniteGalois.instCompactSpaceAlgEquivOfIsGalois | Mathlib.FieldTheory.Galois.Profinite | ∀ (k : Type u_3) (K : Type u_4) [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsGalois k K],
CompactSpace Gal(K/k) | true |
CategoryTheory.instCreatesFiniteLimitsIndFunctorOppositeTypeInclusionOfHasFiniteLimits._proof_1 | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C],
CategoryTheory.Limits.HasLimitsOfShape CategoryTheory.Limits.WalkingParallelPair
(CategoryTheory.Functor Cᵒᵖ (Type u_2)) | false |
CategoryTheory.Idempotents.KaroubiKaroubi.idem_f_assoc | Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C]
(P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)) {Z : C} (h : P.X.X ⟶ Z),
CategoryTheory.CategoryStruct.comp P.p.f (CategoryTheory.CategoryStruct.comp P.p.f h) =
CategoryTheory.CategoryStruct.comp P.p.f h | true |
Std.ExtDHashMap.instInhabited | Std.Data.ExtDHashMap.Basic | {α : Type u} → {β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Inhabited (Std.ExtDHashMap α β) | true |
Matrix.GeneralLinearGroup.toLin_apply | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (A : GL n R) (v : n → R),
↑(Matrix.GeneralLinearGroup.toLin A) v = (↑A).mulVecLin v | true |
Polynomial.homogenize_X | Mathlib.Algebra.Polynomial.Homogenize | ∀ {R : Type u_1} [inst : CommSemiring R] {n : ℕ},
n ≠ 0 → Polynomial.X.homogenize n = MvPolynomial.X 0 * MvPolynomial.X 1 ^ (n - 1) | true |
Lean.Lsp.DiagnosticRelatedInformation.mk | Lean.Data.Lsp.Diagnostics | Lean.Lsp.Location → String → Lean.Lsp.DiagnosticRelatedInformation | true |
_private.Init.Data.Nat.Gcd.0.Nat.gcd_pos_iff._simp_1_1 | Init.Data.Nat.Gcd | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) | false |
zero_sub_zero | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : SubNegZeroMonoid G], 0 - 0 = 0 | true |
PrimeSpectrum.piLocalizationToMaximalEquiv._proof_5 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : PrimeSpectrum.PiLocalization R),
(↑↑(PrimeSpectrum.piLocalizationToMaximal R)).toFun (x * y) =
(↑↑(PrimeSpectrum.piLocalizationToMaximal R)).toFun x * (↑↑(PrimeSpectrum.piLocalizationToMaximal R)).toFun y | false |
isLocalMax_of_mono_anti' | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] {β : Type u_2} [inst_2 : Preorder β] {b : α}
{f : α → β} {a : Set α},
a ∈ nhdsWithin b (Set.Iic b) →
∀ {c : Set α}, c ∈ nhdsWithin b (Set.Ici b) → MonotoneOn f a → AntitoneOn f c → IsLocalMax f b | true |
CategoryTheory.Functor.preservesColimitsOfSize_of_isZero | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasZeroMorphisms D] (G : CategoryTheory.Functor C D),
CategoryTheory.Limits.IsZero G → CategoryTheory.Limits.PreservesColimitsOfSize.... | true |
mem_upperPolar_singleton | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {a : α} {b : β}, b ∈ upperPolar r {a} ↔ r a b | true |
Aesop.Rapp.setSuccessProbability | Aesop.Tree.Data | Aesop.Percent → Aesop.Rapp → Aesop.Rapp | true |
Sym2.GameAdd | Mathlib.Order.GameAdd | {α : Type u_1} → (α → α → Prop) → Sym2 α → Sym2 α → Prop | true |
vadd_preimage_set_subsetₛₗ | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_3} {α : Type u_4} {β : Type u_5} {σ : M → N} [inst : VAdd M α]
[inst_1 : VAdd N β] [inst_2 : FunLike F α β] [AddActionSemiHomClass F σ α β] (f : F) (c : M) (t : Set β),
c +ᵥ ⇑f ⁻¹' t ⊆ ⇑f ⁻¹' (σ c +ᵥ t) | true |
_private.Lean.Server.References.0.Lean.Server.References.findAt.match_1 | Lean.Server.References | (motive : Option (Lean.Lsp.DocumentUri × Lean.Lsp.ModuleRefs × Lean.Lsp.Decls) → Sort u_1) →
(x : Option (Lean.Lsp.DocumentUri × Lean.Lsp.ModuleRefs × Lean.Lsp.Decls)) →
((fst : Lean.Lsp.DocumentUri) →
(refs : Lean.Lsp.ModuleRefs) → (snd : Lean.Lsp.Decls) → motive (some (fst, refs, snd))) →
((x : Op... | false |
ClosedSubmodule.mem_top | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] {x : M}, x ∈ ⊤ | true |
PrincipalSeg.map_succ | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : SuccOrder α] [NoMaxOrder α]
[inst_4 : SuccOrder β] (f : PrincipalSeg (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2) (a : α),
f.toRelEmbedding (Order.succ a) = Order.succ (f.toRelEmbedding a) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.