name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | ∀ {w : ℕ}, 0 ≤ w | false |
CategoryTheory.Limits.HasCokernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
autoParam (∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.Limits.HasCokernel f)
CategoryTheory.Limits.HasCokernels.has_colimit._autoParam →
CategoryTheory.Limits.HasCokernels C | false |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.mahlerSeries_apply_nat._proof_1_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {m n : ℕ}, m ≤ n → ∀ (i : ℕ), m < i + (n + 1) | false |
Lean.Meta.RefinedDiscrTree.Trie.node._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} →
Array α →
Option Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap ℕ Lean.Meta.RefinedDiscrTree.TrieIndex →
Std.HashMap Lean.Meta.RefinedDiscrTree.Key Lean.Meta.RefinedDiscrTree.TrieIndex →
Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) → Lean.Meta.RefinedDiscrTree.Trie α | false |
Lean.Lsp.WorkspaceSymbolParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.WorkspaceSymbolParams → Lean.Lsp.WorkspaceSymbolParams → Sort u | false |
NumberField.mixedEmbedding.fundamentalCone.realSpaceToLogSpace._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x x_1 : NumberField.mixedEmbedding.realSpace K),
(fun w => (x + x_1) ↑w - (↑(↑w).mult * ∑ w', (x + x_1) w') * (↑(Module.finrank ℚ K))⁻¹) =
(fun w => x ↑w - (↑(↑w).mult * ∑ w', x w') * (↑(Module.finrank ℚ K))⁻¹) + fun w =>
x_1 ↑w - (↑(↑w).mult * ∑ w', x_1 w') * (↑(Module.finrank ℚ K))⁻¹ | false |
Int.lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.lcm (a * b) = a.natAbs * b.natAbs | true |
qExpansionRingHom | Mathlib.NumberTheory.ModularForms.QExpansion | {Γ : Subgroup (GL (Fin 2) ℝ)} →
(h : ℝ) →
[inst : Γ.HasDetPlusMinusOne] →
0 < h → h ∈ Γ.strictPeriods → (DirectSum ℤ fun k => ModularForm Γ k) →+* PowerSeries ℂ | true |
UInt32.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt32}, c ≠ -1 → c < c + 1 | true |
PrimeMultiset.prod | Mathlib.Data.PNat.Factors | PrimeMultiset → ℕ+ | true |
String.Slice.Pattern.ToForwardSearcher.mk | Init.Data.String.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
{σ : outParam (String.Slice → Type)} →
((s : String.Slice) → Std.Iter (String.Slice.Pattern.SearchStep s)) → String.Slice.Pattern.ToForwardSearcher pat σ | true |
UpperHalfPlane.num._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | NeZero (1 + 1) | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEqIffEnumToBitVecEqFor | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Lean.Name → Lean.MetaM Lean.Name | true |
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
[Algebra.IsSeparable F ↥L] {x : E}, x ∈ L → IsSeparable F x | true |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : 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) [CharZero R]
[IsAddTorsionFree M] [P.IsReduced] {n : ℕ} [n.AtLeastTwo] {i : ι}, n • P.root i ∉ Set.range ⇑P.root | true |
Aesop.GoalId.casesOn | Aesop.Tree.Data | {motive : Aesop.GoalId → Sort u} → (t : Aesop.GoalId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t | false |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B →
CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Discrete PUnit.{1})) B | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) →
((x x_2 : Lean.Lsp.RefIdent) → motive x x_2) → motive x x_1 | false |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (r : R)
(m : A), ↑(r • m) = r • ↑m | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | (motive : Option UInt16 → Sort u_1) →
(__do_lift : Option UInt16) → ((n : UInt16) → motive (some n)) → ((x : Option UInt16) → motive x) → motive __do_lift | false |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (ha : 0 ≤ a) (hb : 0 ≤ b),
(∀ (w w_1 : ℕ) (ha : 0 ≤ ↑w) (hb : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ ha hb) → motive a b x x_1 ha hb | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y | false |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ : Module R₃ M₃}
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_6 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (f : M₂ →ₛₗ[σ₂₃] M₃)
(g : M₁ →ₛₗ[σ₁₂] M₂), ⇑f ∘ ⇑g = ⇑(f ∘ₛₗ g) | false |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m []) = m | true |
List.dropLast_append_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast | true |
Subarray.scanlM.eq_1 | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β)
(as : Subarray α), Subarray.scanlM f init as = Array.scanlM f init as.array as.start as.stop | true |
MeasureTheory.Measure.sum_fintype | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [inst : Fintype ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.Measure.sum μ = ∑ i, μ i | true |
LightCondensed.instMonoidalClosedFunctorOppositeLightProfiniteModuleCat._proof_1 | Mathlib.Condensed.Light.Monoidal | ∀ (R : Type u_1) [inst : CommRing R], (CategoryTheory.equivSmallModel LightProfinite).op.congrLeft.functor.IsEquivalence | false |
Finset.preimage_add_right_zero' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {b : α}, Finset.preimage 0 (fun x => x + -b) ⋯ = {b} | true |
FreeAddMagma.add | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → FreeAddMagma α → FreeAddMagma α | true |
Lean.Meta.FindSplitImpl.Context.recOn | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.FindSplitImpl.Context → Sort u} →
(t : Lean.Meta.FindSplitImpl.Context) →
((exceptionSet : Lean.ExprSet) →
(kind : Lean.Meta.SplitKind) → motive { exceptionSet := exceptionSet, kind := kind }) →
motive t | false |
Lean.Lsp.FoldingRange.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{startLine endLine : ℕ} →
{kind? : Option Lean.Lsp.FoldingRangeKind} →
{startLine' endLine' : ℕ} →
{kind?' : Option Lean.Lsp.FoldingRangeKind} →
{ startLine := startLine, endLine := endLine, kind? := kind? } =
{ startLine := startLine', endLine := endLine', kind? := kind?' } →
(startLine = startLine' → endLine = endLine' → kind? = kind?' → P) → P | false |
Lean.Meta.AC.PreExpr.brecOn.go | Lean.Meta.Tactic.AC.Main | {motive : Lean.Meta.AC.PreExpr → Sort u} →
(t : Lean.Meta.AC.PreExpr) →
((t : Lean.Meta.AC.PreExpr) → Lean.Meta.AC.PreExpr.below t → motive t) → motive t ×' Lean.Meta.AC.PreExpr.below t | true |
Set.opEquiv_self | Mathlib.Data.Set.Opposite | {α : Type u_1} → (s : Set α) → ↑s.op ≃ ↑s | true |
Complex.sin_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Function.Surjective Complex.sin | true |
Module.FinitePresentation.linearEquivMap._proof_3 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | false |
Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (A : Type u_1) [Field A], Nontrivial A | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_560 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h :
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w [g (g a)] {g a, g (g a)}.card] <
[g a, g (g a)].length | false |
AddCon.ker.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → AddCon.ker f = AddCon.ker f_1 | true |
CategoryTheory.Functor.chosenProd.fst | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ X | true |
FinBoolAlg.hasForgetToFinBddDistLat._proof_4 | Mathlib.Order.Category.FinBoolAlg | { obj := fun X => FinBddDistLat.of ↑X.toBoolAlg, map := fun {X Y} f => FinBddDistLat.ofHom (BoolAlg.Hom.hom f.hom),
map_id := FinBoolAlg.hasForgetToFinBddDistLat._proof_1,
map_comp := @FinBoolAlg.hasForgetToFinBddDistLat._proof_2 }.comp
(CategoryTheory.forget FinBddDistLat) =
CategoryTheory.forget FinBoolAlg | false |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_3 | Mathlib.Order.Interval.Finset.Nat | ∀ {a b c : ℕ} (x : ℕ), a - c ≤ x ∧ x < b - c → (a ≤ x + c ∧ x + c < b) ∧ x + c - c = x | false |
ENNReal.add_halves | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a / 2 + a / 2 = a | true |
Finset.map_insert | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α ↪ β) (a : α) (s : Finset α),
Finset.map f (insert a s) = insert (f a) (Finset.map f s) | true |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop.match_1 | Init.Data.Array.InsertionSort | (motive : ℕ → Sort u_1) → (j : ℕ) → (j = 0 → motive 0) → ((j' : ℕ) → j = j'.succ → motive j'.succ) → motive j | false |
NNReal.instLinearOrder._aux_6 | Mathlib.Data.NNReal.Defs | DecidableEq NNReal | false |
RingHomId.eq_id | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R : Type u_4} {inst : Semiring R} {σ : R →+* R} [self : RingHomId σ], σ = RingHom.id R | true |
LinearEquiv.piRing | Mathlib.LinearAlgebra.Pi | (R : Type u) →
(M : Type v) →
(ι : Type x) →
[inst : Semiring R] →
(S : Type u_4) →
[Fintype ι] →
[DecidableEq ι] →
[inst_3 : Semiring S] →
[inst_4 : AddCommMonoid M] →
[inst_5 : Module R M] →
[inst_6 : Module S M] → [inst_7 : SMulCommClass R S M] → ((ι → R) →ₗ[R] M) ≃ₗ[S] ι → M | true |
Std.Internal.List.maxKeyD_le_maxKeyD_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k} {fallback : α},
(compare (Std.Internal.List.maxKeyD l fallback)
(Std.Internal.List.maxKeyD (Std.Internal.List.insertEntry k v l) fallback)).isLE =
true | true |
Finset.prod_ite_of_false | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} {s : Finset ι} [inst : CommMonoid M] {p : ι → Prop} [inst_1 : DecidablePred p],
(∀ x ∈ s, ¬p x) → ∀ (f g : ι → M), (∏ x ∈ s, if p x then f x else g x) = ∏ x ∈ s, g x | true |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit.match_1 | Lean.Meta.ExprTraverse | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (c : Lean.BinderInfo) → motive (Lean.Expr.forallE n d b c)) →
((e : Lean.Expr) → motive e) → motive x | false |
Equiv.recOn | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} →
{β : Sort u_2} →
{motive : α ≃ β → Sort u} →
(t : α ≃ β) →
((toFun : α → β) →
(invFun : β → α) →
(left_inv : Function.LeftInverse invFun toFun) →
(right_inv : Function.RightInverse invFun toFun) →
motive { toFun := toFun, invFun := invFun, left_inv := left_inv, right_inv := right_inv }) →
motive t | false |
Continuous.cfcₙ_nnreal'._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
topologicalAddGroup_inf | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : AddGroup G] {t₁ t₂ : TopologicalSpace G},
IsTopologicalAddGroup G → IsTopologicalAddGroup G → IsTopologicalAddGroup G | true |
Acc.casesOn | Init.WF | {α : Sort u} →
{r : α → α → Prop} →
{motive : (a : α) → Acc r a → Sort u_1} →
{a : α} → (t : Acc r a) → ((x : α) → (h : ∀ (y : α), r y x → Acc r y) → motive x ⋯) → motive a t | false |
Function.Embedding.instAddAction._proof_1 | Mathlib.GroupTheory.GroupAction.Embedding | ∀ {α : Type u_1} {β : Type u_2}, Function.Injective fun f => ⇑f | false |
Multiset.powerset._proof_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} (x x_1 : List α),
(List.isSetoid α) x x_1 →
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x) =
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x_1) | false |
ZFSet.Insert.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (b : (PSet.mk α_1 A_1).Type)
(motive : (∃ a, (A a).Equiv (A_1 b)) → Prop) (x : ∃ a, (A a).Equiv (A_1 b)),
(∀ (a : α) (ha : (A a).Equiv (A_1 b)), motive ⋯) → motive x | false |
List.Sublist.flatMap | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α},
l₁.Sublist l₂ → ∀ (f : α → List β), (List.flatMap f l₁).Sublist (List.flatMap f l₂) | true |
Ring.zsmul | Mathlib.Algebra.Ring.Defs | {R : Type u} → [self : Ring R] → ℤ → R → R | true |
MeasureTheory.StronglyAdapted.progMeasurable_of_continuous | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι]
[TopologicalSpace.MetrizableSpace ι] [SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpace ι]
[TopologicalSpace.PseudoMetrizableSpace β],
MeasureTheory.StronglyAdapted f u → (∀ (ω : Ω), Continuous fun i => u i ω) → MeasureTheory.ProgMeasurable f u | true |
Equiv.simpleGraph | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → {W : Type u_2} → V ≃ W → SimpleGraph V ≃ SimpleGraph W | true |
Std.Internal.List.minKey!_insertEntryIfNew_le_minKey! | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k},
(compare (Std.Internal.List.minKey! (Std.Internal.List.insertEntryIfNew k v l))
(Std.Internal.List.minKey! l)).isLE =
true | true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [NonUnitalNonAssocSemiring R] → NonUnitalNonAssocSemiring (QuadraticAlgebra R a b) | true |
CompactlySupportedContinuousMap.smulc_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Zero β] [inst_3 : TopologicalSpace γ] [inst_4 : SMulZeroClass γ β] [inst_5 : ContinuousSMul γ β]
{F : Type u_5} [inst_6 : FunLike F α γ] [inst_7 : ContinuousMapClass F α γ] (f : F)
(g : CompactlySupportedContinuousMap α β) (x : α), (f • g) x = f x • g x | true |
Lean.Meta.Grind.SplitInfo.arg | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Meta.Grind.SplitSource → Lean.Meta.Grind.SplitInfo | true |
_private.Mathlib.Data.PFun.0.PFun.mem_prodLift._simp_1_6 | Mathlib.Data.PFun | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeftIsLimit | Mathlib.Geometry.RingedSpace.OpenImmersion | {X Y Z : AlgebraicGeometry.LocallyRingedSpace} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f] →
CategoryTheory.Limits.IsLimit (AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeft f g) | true |
List.dropWhile.eq_def | Init.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (x : List α),
List.dropWhile p x =
match x with
| [] => []
| a :: l =>
match p a with
| true => List.dropWhile p l
| false => a :: l | true |
Finsupp.mem_submodule_iff | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
(S : α → Submodule R M) (x : α →₀ M), x ∈ Finsupp.submodule S ↔ ∀ (i : α), x i ∈ S i | true |
Submonoid.val_mem_of_mem_units | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ}, x ∈ S.units → ↑x ∈ S | true |
Finsupp.mem_neLocus | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N}
{a : α}, a ∈ f.neLocus g ↔ f a ≠ g a | true |
Std.DTreeMap.isSome_minKey?_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.minKey?.isSome = true | true |
CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : CategoryTheory.Preadditive D] [inst_7 : F.Additive] (n : ℤ)
(X : CategoryTheory.Pretriangulated.Triangle C),
((F.mapTriangleCommShiftIso n).inv.app X).hom₁ = (CategoryTheory.Functor.commShiftIso F n).inv.app X.obj₁ | true |
Nat.Partrec.Code.ofNatCode.eq_4 | Mathlib.Computability.PartrecCode | Nat.Partrec.Code.ofNatCode 3 = Nat.Partrec.Code.right | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_fmod_unique'._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ}, b < 0 → ¬0 < -b → False | false |
Lean.Doc.Syntax.directive._regBuiltin.Lean.Doc.Syntax.directive.docString_1 | Lean.DocString.Syntax | IO Unit | false |
ArchimedeanClass.mk_nonneg_of_le_of_le_of_archimedean | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {S : Type u_3}
[inst_3 : LinearOrder S] [inst_4 : CommRing S] [IsStrictOrderedRing S] [Archimedean S] (f : S →+*o R) {x : R}
{r s : S}, f r ≤ x → x ≤ f s → 0 ≤ ArchimedeanClass.mk x | true |
CommRingCat.Colimits.instCommRingColimitType._proof_9 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x : CommRingCat.Colimits.ColimitType F), 0 * x = 0 | false |
Quaternion.imJ_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), (star a).imJ = -a.imJ | true |
List.splitAtD.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → α → ℕ → List α → List α → List α × List α | false |
Lean.Meta.LazyDiscrTree.recOn | Lean.Meta.LazyDiscrTree | {α : Type} →
{motive : Lean.Meta.LazyDiscrTree α → Sort u} →
(t : Lean.Meta.LazyDiscrTree α) →
((tries : Array (Lean.Meta.LazyDiscrTree.Trie α)) →
(roots : Std.HashMap Lean.Meta.LazyDiscrTree.Key Lean.Meta.LazyDiscrTree.TrieIndex) →
motive { tries := tries, roots := roots }) →
motive t | false |
Mathlib.Tactic.Ring.ringCleanupRef | Mathlib.Tactic.Ring.Basic | IO.Ref (Lean.Expr → Lean.MetaM Lean.Expr) | true |
VitaliFamily.FineSubfamilyOn.index | Mathlib.MeasureTheory.Covering.VitaliFamily | {X : Type u_1} →
[inst : PseudoMetricSpace X] →
{m0 : MeasurableSpace X} →
{μ : MeasureTheory.Measure X} →
{v : VitaliFamily μ} → {f : X → Set (Set X)} → {s : Set X} → v.FineSubfamilyOn f s → Set (X × Set X) | true |
SimpleGraph.Walk.IsHamiltonian.fintype._proof_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a b : α} {p : G.Walk a b},
p.IsHamiltonian → ∀ (x : α), x ∈ p.support.toFinset | false |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.suggestName.match_4 | Lean.Elab.DocString.Builtin | (motive : Lean.Exception → Sort u_1) → (ex : Lean.Exception) → ((x : Lean.Exception) → motive x) → motive ex | false |
Nat.odd_sub._simp_1 | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → Odd (m - n) = (Odd m ↔ Even n) | false |
CategoryTheory.Functor.elementsFunctor_map | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Functor C (Type w)} (n : X ⟶ Y),
CategoryTheory.Functor.elementsFunctor.map n = (CategoryTheory.NatTrans.mapElements n).toCatHom | true |
WithZeroMulInt.toNNReal_le_one_iff | Mathlib.Data.Int.WithZero | ∀ {e : NNReal} {m : WithZero (Multiplicative ℤ)} (he : 1 < e), (WithZeroMulInt.toNNReal ⋯) m ≤ 1 ↔ m ≤ 1 | true |
Algebra.transcendental_ringHom_iff_of_comp_eq | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] {B : Type u_2} [inst_4 : Ring B] [inst_5 : Algebra S B] {FRS : Type u_3} {FAB : Type u_4}
[inst_6 : EquivLike FRS R S] [inst_7 : RingEquivClass FRS R S] [inst_8 : EquivLike FAB A B]
[inst_9 : RingEquivClass FAB A B] (f : FRS) (g : FAB),
(algebraMap S B).comp ↑f = (↑g).comp (algebraMap R A) → (Algebra.Transcendental S B ↔ Algebra.Transcendental R A) | true |
padicValRat.of_int | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} {z : ℤ}, padicValRat p ↑z = ↑(padicValInt p z) | true |
orderBornology_isBounded._simp_1 | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s : Set α} [inst : Lattice α] [inst_1 : Nonempty α], Bornology.IsBounded s = (BddBelow s ∧ BddAbove s) | false |
Std.Tactic.BVDecide.LRAT.Internal.Formula.rupAdd_sound | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | ∀ {α : outParam (Type u)} {β : outParam (Type v)} {inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} {σ : Type w}
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} [self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ) (c : β) (rupHints : Array ℕ) (f' : σ),
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRupAdd f →
Std.Tactic.BVDecide.LRAT.Internal.Formula.performRupAdd f c rupHints = (f', true) →
Std.Tactic.BVDecide.LRAT.Internal.Liff α f f' | true |
CategoryTheory.Precoherent.recOn | Mathlib.CategoryTheory.Sites.Coherent.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Precoherent C → Sort u} →
(t : CategoryTheory.Precoherent C) →
((pullback :
∀ {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁),
CategoryTheory.EffectiveEpiFamily X₁ π₁ →
∃ β,
∃ (_ : Finite β),
∃ X₂ π₂,
CategoryTheory.EffectiveEpiFamily X₂ π₂ ∧
∃ i ι,
∀ (b : β),
CategoryTheory.CategoryStruct.comp (ι b) (π₁ (i b)) =
CategoryTheory.CategoryStruct.comp (π₂ b) f) →
motive ⋯) →
motive t | false |
ProbabilityTheory.Kernel.ae_compProd_iff | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ]
{η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} {p : β × γ → Prop},
MeasurableSet {x | p x} →
((∀ᵐ (bc : β × γ) ∂(κ.compProd η) a, p bc) ↔ ∀ᵐ (b : β) ∂κ a, ∀ᵐ (c : γ) ∂η (a, b), p (b, c)) | true |
max_mul_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] (a b c : α), max (a * b) (a * c) = a * max b c | true |
Equiv.forall_congr' | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β),
(∀ (b : β), p (e.symm b) ↔ q b) → ((∀ (a : α), p a) ↔ ∀ (b : β), q b) | true |
CategoryTheory.congr_app | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} {α β : CategoryTheory.NatTrans F G}, α = β → ∀ (X : C), α.app X = β.app X | true |
Fintype.linearIndependent_iffₛ | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v ↔ ∀ (f g : ι → R), ∑ i, f i • v i = ∑ i, g i • v i → ∀ (i : ι), f i = g i | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.