name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Polynomial.coeff_shiftedLegendre | Mathlib.RingTheory.Polynomial.ShiftedLegendre | ∀ (n k : ℕ), (Polynomial.shiftedLegendre n).coeff k = (-1) ^ k * ↑(n.choose k) * ↑((n + k).choose n) | true |
Subgroup.isFiniteRelIndex_iff_relIndex_ne_zero | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, H.IsFiniteRelIndex K ↔ H.relIndex K ≠ 0 | true |
_private.Mathlib.Util.AtomM.Recurse.0.Mathlib.Tactic.AtomM.RecurseM.run.evalAtom | Mathlib.Util.AtomM.Recurse | IO.Ref Mathlib.Tactic.AtomM.State →
Mathlib.Tactic.AtomM.Recurse.Config →
Bool →
(Lean.Expr → Mathlib.Tactic.AtomM Lean.Meta.Simp.Result) →
Mathlib.Tactic.AtomM.Recurse.Context → Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | true |
Set.image_single_Ico | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : (i : ι) → Zero (α i)] (i : ι) (a b : α i),
Pi.single i '' Set.Ico a b = Set.Ico (Pi.single i a) (Pi.single i b) | true |
String.ofList_cons | Init.Data.String.Lemmas.Basic | ∀ {c : Char} {l : List Char}, String.ofList (c :: l) = String.singleton c ++ String.ofList l | true |
LieSubmodule.mk.congr_simp | Mathlib.Algebra.Lie.BaseChange | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (toSubmodule toSubmodule_1 : Submodule R M)
(e_toSubmodule : toSubmodule = toSubmodule_1)
(lie_mem : ∀ {x : L} {m : M}, m ∈ toSubmodule.carrier → ⁅x, m⁆ ∈ ... | true |
Std.Channel.Sync.send | Std.Sync.Channel | {α : Type} → Std.Channel.Sync α → α → BaseIO Unit | true |
Field.DirectLimit.field._proof_16 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : Nonempty ι] [inst_2 : IsDirectedOrder ι]
[inst_3 : (i : ι) → Field (G i)] (f' : (i j : ι) → i ≤ j → G i →+* G j) (x : ℚ)
(x_1 : Ring.DirectLimit G fun x1 x2 x3 => ⇑(f' x1 x2 x3)), ↑x * x_1 = ↑x * x_1 | false |
«term‖_‖ₑ» | Mathlib.Analysis.Normed.Group.Defs | Lean.ParserDescr | true |
Submodule.finrank_map_le | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M']
[inst_3 : Module R M] [StrongRankCondition R] [inst_5 : Module R M'] (f : M →ₗ[R] M') (p : Submodule R M)
[Module.Finite R ↥p], Module.finrank R ↥(Submodule.map f p) ≤ Module.finrank R ↥p | true |
AdicCompletion.map_id | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
AdicCompletion.map I LinearMap.id = LinearMap.id | true |
exists_nat_pow_near_of_lt_one | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_4} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {x y : K}
[ExistsAddOfLE K], 0 < x → x ≤ 1 → 0 < y → y < 1 → ∃ n, y ^ (n + 1) < x ∧ x ≤ y ^ n | true |
Equiv.Perm.cycleType.congr_simp | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] {inst_1 : DecidableEq α} [inst_2 : DecidableEq α] (σ σ_1 : Equiv.Perm α),
σ = σ_1 → σ.cycleType = σ_1.cycleType | true |
SimpleGraph.edist_pos_of_ne | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, u ≠ v → 0 < G.edist u v | true |
CategoryTheory.Limits.fiberwiseColimitLimitIso._proof_10 | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {H : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} H] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{F : CategoryTheory.Functor C CategoryTheory.Cat}
(K : CategoryTheory.Functor J (CategoryTheory.Functor (CategoryTheory.Groth... | false |
Path.Homotopic.Quotient.ind | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x y : X} {motive : Path.Homotopic.Quotient x y → Prop},
(∀ (a : Path x y), motive (Path.Homotopic.Quotient.mk a)) → ∀ (q : Path.Homotopic.Quotient x y), motive q | true |
_private.Mathlib.LinearAlgebra.Dual.BaseChange.0.IsBaseChange.toDualBaseChangeAux.eq_1 | Mathlib.LinearAlgebra.Dual.BaseChange | ∀ {R : Type u_1} [inst : CommSemiring R] {V : Type u_2} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommMonoid W] [inst_4 : Module R W] {A : Type u_4} [inst_5 : CommSemiring A] [inst_6 : Algebra R A]
[inst_7 : Module A W] [inst_8 : IsScalarTower R A W] {j : V →ₗ[R] W} (ibc : IsBaseC... | true |
CategoryTheory.Monad.Algebra.isoMk_inv_f | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra}
(h : A.A ≅ B.A)
(w :
autoParam (CategoryTheory.CategoryStruct.comp (T.map h.hom) B.a = CategoryTheory.CategoryStruct.comp A.a h.hom)
CategoryTheory.Monad.Algebra.isoMk._auto_1),
(CategoryTheory.Mon... | true |
CategoryTheory.Presieve.FamilyOfElements.map_apply | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P Q : CategoryTheory.Functor Cᵒᵖ (Type w)} {X : C}
{R : CategoryTheory.Presieve X} (p : CategoryTheory.Presieve.FamilyOfElements P R) (φ : P ⟶ Q) {Y : C} (f : Y ⟶ X)
(hf : R f), p.map φ f hf = φ.app (Opposite.op Y) (p f hf) | true |
MeasureTheory.exists_measurable_le_forall_setLIntegral_eq | Mathlib.MeasureTheory.Integral.Lebesgue.Countable | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [MeasureTheory.SFinite μ] (f : α → ENNReal),
∃ g, Measurable g ∧ g ≤ f ∧ ∀ (s : Set α), ∫⁻ (a : α) in s, f a ∂μ = ∫⁻ (a : α) in s, g a ∂μ | true |
Filter.EventuallyEq.mem_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s t : Set α} {l : Filter α}, s =ᶠ[l] t → ∀ᶠ (x : α) in l, x ∈ s ↔ x ∈ t | true |
Polynomial.taylor_inj | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : Ring R] {r : R} {p q : Polynomial R}, (Polynomial.taylor r) p = (Polynomial.taylor r) q ↔ p = q | true |
Metric.equicontinuousAt_iff_right | Mathlib.Topology.MetricSpace.Equicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] {ι : Type u_4} [inst_1 : TopologicalSpace β]
{F : ι → β → α} {x₀ : β}, EquicontinuousAt F x₀ ↔ ∀ ε > 0, ∀ᶠ (x : β) in nhds x₀, ∀ (i : ι), dist (F i x₀) (F i x) < ε | true |
List.maxIdxOn?_eq_some_zero_iff | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {xs : List α}
{f : α → β}, List.maxIdxOn? f xs = some 0 ↔ ∃ (h : xs ≠ []), ∀ x ∈ xs, f x ≤ f (xs.head h) | true |
List.Sorted.head!_le | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {a : α} [inst : Inhabited α] [Std.Refl R],
List.Pairwise R l → a ∈ l → R l.head! a | true |
Std.ExtDHashMap.get?_erase | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k a : α},
(m.erase k).get? a = if (k == a) = true then none else m.get? a | true |
Int.gcd_sub_mul_left_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), m.gcd (n - m * k) = m.gcd n | true |
Nat.log_two_bit | Mathlib.Data.Nat.Log | ∀ {b : Bool} {n : ℕ}, n ≠ 0 → Nat.log 2 (Nat.bit b n) = Nat.log 2 n + 1 | true |
Homeomorph.Set.univ._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | ∀ (X : Type u_1) [inst : TopologicalSpace X], Continuous (Equiv.Set.univ X).toFun | false |
Int64.toISize_ofInt | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, (Int64.ofInt n).toISize = ISize.ofInt n | true |
Char.utf8Size.eq_1 | Init.Data.String.Decode | ∀ (c : Char),
c.utf8Size =
if c.val ≤ UInt32.ofNatLT 127 Char.utf8Size._proof_1 then 1
else
if c.val ≤ UInt32.ofNatLT 2047 Char.utf8Size._proof_2 then 2
else if c.val ≤ UInt32.ofNatLT 65535 Char.utf8Size._proof_3 then 3 else 4 | true |
CategoryTheory.Functor.LaxMonoidal.μ_natural_left._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
Lean.Widget.GetInteractiveDiagnosticsParams.recOn | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.GetInteractiveDiagnosticsParams → Sort u} →
(t : Lean.Widget.GetInteractiveDiagnosticsParams) →
((lineRange? : Option Lean.Lsp.LineRange) → motive { lineRange? := lineRange? }) → motive t | false |
Lean.Lsp.SignatureInformation.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.SignatureInformation → Lean.Lsp.SignatureInformation → Sort u | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.typeOccursCheckImp.visit.match_1 | Lean.Meta.ExprDefEq | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((typeName : Lean.Name) → (idx : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj typeName idx s)) →
((f a : Lean.Expr) → motive (f.app a)) →
((binderName : Lean.Nam... | false |
CategoryTheory.StructuredArrow.mapNatIso_counitIso_hom_app_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : D} {T T' : CategoryTheory.Functor C D} (i : T ≅ T')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T'),
((CategoryTheory.StructuredArrow.mapNatIso i).counitIso.hom.app X).ri... | true |
FreeAbelianGroup.seq_add | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α β : Type u} (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α), f <*> x + y = (f <*> x) + (f <*> y) | true |
BitVec.getElem_and | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w} {i : ℕ} (h : i < w), (x &&& y)[i] = (x[i] && y[i]) | true |
Equiv.swap | Mathlib.Logic.Equiv.Basic | {α : Sort u_1} → [DecidableEq α] → α → α → Equiv.Perm α | true |
MulRingSeminorm.ext | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : NonAssocRing R] {p q : MulRingSeminorm R}, (∀ (x : R), p x = q x) → p = q | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_inter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Lean.Parser.TokenMap.instInhabited | Lean.Parser.Basic | {α : Type} → Inhabited (Lean.Parser.TokenMap α) | true |
_private.Mathlib.Algebra.CharP.Two.0.CharTwo.multiset_sum_mul_self._simp_1_1 | Mathlib.Algebra.CharP.Two | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | false |
Lean.Lsp.CompletionItemTag | Lean.Data.Lsp.LanguageFeatures | Type | true |
bddBelow_smul_iff_of_neg._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β]
{s : Set β} {a : α}, a < 0 → BddBelow (a • s) = BddAbove s | false |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_natAddEmb_uIcc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
MvPowerSeries.HasSubst.smul | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {τ : Type u_4} {S : Type u_5} [inst : CommRing S] (r : MvPowerSeries τ S) {a : σ → MvPowerSeries τ S},
MvPowerSeries.HasSubst a → MvPowerSeries.HasSubst (r • a) | true |
Lean.Parser.Term.macroArg.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
Multiset.powerset_aux'_perm | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → (Multiset.powersetAux' l₁).Perm (Multiset.powersetAux' l₂) | true |
Lean.Compiler.LCNF.ImpureType.float | Lean.Compiler.LCNF.Types | Lean.Expr | true |
Polynomial.IsSplittingField.lift | Mathlib.FieldTheory.SplittingField.IsSplittingField | {F : Type u} →
{K : Type v} →
(L : Type w) →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Field F] →
[inst_3 : Algebra K L] →
[inst_4 : Algebra K F] →
(f : Polynomial K) →
[Polynomial.IsSplittingField K L f] → (Polynomial.map... | true |
CategoryTheory.Functor.hasPointwiseRightDerivedFunctorAt_iff | Mathlib.CategoryTheory.Functor.Derived.PointwiseRightDerived | ∀ {C : Type u₁} {D : Type u₂} {H : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C]
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] [inst_2 : CategoryTheory.Category.{v₃, u₃} H]
(F : CategoryTheory.Functor C H) (L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C)
[L.IsLocalization W] (X : C)... | true |
AddHom.rec | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Add M] →
[inst_1 : Add N] →
{motive : (M →ₙ+ N) → Sort u} →
((toFun : M → N) →
(map_add' : ∀ (x y : M), toFun (x + y) = toFun x + toFun y) →
motive { toFun := toFun, map_add' := map_add' }) →
(t : M →ₙ+ N... | false |
CategoryTheory.Limits.IsLimit.overPost._proof_4 | Mathlib.CategoryTheory.Limits.Final | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {D : CategoryTheory.Functor J C} (j : J) (k : CategoryTheory.Over j),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
((CategoryTheory.Over.lift ((CategoryTheory.... | false |
CategoryTheory.ShortComplex.HomologyData.mk.injEq | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (left : S.LeftHomologyData) (right : S.RightHomologyData) (iso : left.H ≅ right.H)
(comm :
autoParam
(CategoryTheory.CategoryStruct.comp left.π (CategoryTheory.C... | true |
Std.Tactic.BVDecide.BVUnOp.eval_rotateRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {n w : ℕ}, (Std.Tactic.BVDecide.BVUnOp.rotateRight n).eval = fun x => x.rotateRight n | true |
OrderMonoidIso.equivLike_inv_eq_symm | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(f : α ≃*o β), EquivLike.inv f = ⇑f.symm | true |
_private.Mathlib.Topology.Separation.Basic.0.exists_isOpen_mem_isCompact_closure._simp_1_1 | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | false |
SSet.Subcomplex.PairingCore.IsInner.rec | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} →
{A : X.Subcomplex} →
{h : A.PairingCore} →
{motive : h.IsInner → Sort u_2} →
((ne_zero : ∀ (s : h.ι), h.index s ≠ 0) →
(ne_last : ∀ (s : h.ι), h.index s ≠ Fin.last (h.dim s + 1)) → motive ⋯) →
(t : h.IsInner) → motive t | false |
PadicSeq.stationaryPoint_spec | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) {m n : ℕ},
PadicSeq.stationaryPoint hf ≤ m → PadicSeq.stationaryPoint hf ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m) | true |
Aesop.Script.LazyStep.noConfusionType | Aesop.Script.Step | Sort u → Aesop.Script.LazyStep → Aesop.Script.LazyStep → Sort u | false |
Cardinal.mk_Ioo_real | Mathlib.Analysis.Real.Cardinality | ∀ {a b : ℝ}, a < b → Cardinal.mk ↑(Set.Ioo a b) = Cardinal.continuum | true |
Plausible.Fact.printableProp | Mathlib.Testing.Plausible.Testable | {p : Prop} → [Plausible.PrintableProp p] → Plausible.PrintableProp (Fact p) | true |
instDecidableEqNONote | Mathlib.SetTheory.Ordinal.Notation | DecidableEq NONote | true |
_private.Mathlib.Order.KrullDimension.0.Order.height_le._proof_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] ⦃p : LTSeries α⦄, p.length ≠ 0 → p.length = p.length - 1 + 1 | false |
Partition.bot_lt_of_mem | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {s x : α} [inst : CompleteLattice α] {P : Partition s}, x ∈ P → ⊥ < x | true |
LieAdmissibleAlgebra | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | (R : Type u_1) → (L : Type u_2) → [CommRing R] → [LieAdmissibleRing L] → Type (max u_1 u_2) | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.get?_union_of_contains_eq_false_right._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | false |
WithTop.coe_ofNat | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : AddMonoidWithOne α] (n : ℕ) [inst_1 : n.AtLeastTwo], ↑(OfNat.ofNat n) = OfNat.ofNat n | true |
CategoryTheory.MorphismProperty.IsMultiplicative.unop | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty Cᵒᵖ) [W.IsMultiplicative],
W.unop.IsMultiplicative | true |
Std.Internal.List.maxKey_alterKey_eq_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
[inst_4 : Std.LawfulEqOrd α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {f : Option (β k) → Option (β k)} {he : (Std.Internal.List.alterKey k f l).isEmpty = false},
... | true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_29 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} (y : α) (tail : List α),
List.idxOf a (y :: tail) - 2 + 1 ≤ tail.length → List.idxOf a (y :: tail) - 2 < tail.length | false |
Unique.default_eq | Mathlib.Logic.Unique | ∀ {α : Sort u_1} [inst : Unique α] (a : α), default = a | true |
ValueDistribution.logCounting_top | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {f : 𝕜 → E},
ValueDistribution.logCounting f ⊤ = Function.locallyFinsuppWithin.logCounting (MeromorphicOn.divisor f Set.univ)⁻ | true |
HasFDerivWithinAt.abs_of_pos | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {s : Set E}
{x : E}, HasFDerivWithinAt f f' s x → 0 < f x → HasFDerivWithinAt (fun x => |f x|) f' s x | true |
_private.Mathlib.LinearAlgebra.UnitaryGroup.0.Matrix.mem_unitaryGroup_iff._simp_1_1 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {M : Type u_2} [inst : MulOne M] [IsDedekindFiniteMonoid M] {a b : M}, (a * b = 1) = (b * a = 1) | false |
Array.findIdx_le_findIdx | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p q : α → Bool},
(∀ x ∈ xs, p x = true → q x = true) → Array.findIdx q xs ≤ Array.findIdx p xs | true |
EuclideanGeometry.Sphere.IsTangentAt.inner_left_eq_zero_of_mem | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p : P} {as : AffineSubspace ℝ P},
s.IsTangentAt p as → ∀ {x : P}, x ∈ as → inner ℝ (x -ᵥ p) (p -ᵥ s.center) = 0 | true |
EStateM.dummySave | Init.Prelude | {σ : Type u} → σ → PUnit.{u_1} | true |
isClosedMap_mul_left | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] (a : G),
IsClosedMap fun x => a * x | true |
Set.unbounded_lt_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] [NoMaxOrder α] (a : α),
Set.Unbounded (fun x1 x2 => x1 < x2) (s ∩ {b | a < b}) ↔ Set.Unbounded (fun x1 x2 => x1 < x2) s | true |
TuringEquivalent.refl | Mathlib.Computability.TuringDegree | ∀ (f : ℕ →. ℕ), TuringEquivalent f f | true |
ProofWidgets.CheckRequestResponse.running.sizeOf_spec | ProofWidgets.Cancellable | sizeOf ProofWidgets.CheckRequestResponse.running = 1 | true |
PerfectClosure.R.rec | Mathlib.FieldTheory.PerfectClosure | ∀ {K : Type u} [inst : CommRing K] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
{motive : (a a_1 : ℕ × K) → PerfectClosure.R K p a a_1 → Prop},
(∀ (n : ℕ) (x : K), motive (n, x) (n + 1, (frobenius K p) x) ⋯) →
∀ {a a_1 : ℕ × K} (t : PerfectClosure.R K p a a_1), motive a a_1 t | false |
CategoryTheory.Under.opEquivOpOver_counitIso | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T),
(CategoryTheory.Under.opEquivOpOver X).counitIso =
CategoryTheory.Iso.refl
({ obj := fun Y => CategoryTheory.Under.mk (Opposite.unop Y).hom.op,
map := fun {Z Y} f => CategoryTheory.Under.homMk f.unop.left.op ⋯, map_id := ⋯, map... | true |
CategoryTheory.Oplax.OplaxTrans.Hom.of.injEq | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (as as_1 : CategoryTheory.Oplax.OplaxTrans.Modification η θ),
({ as := as } = { as := as_1 }) = (as = as_1) | true |
_private.Init.Data.Char.Ordinal.0.Char.ordinal_le_of_le._simp_1_1 | Init.Data.Char.Ordinal | ∀ {a b : Char}, (a ≤ b) = (a.val ≤ b.val) | false |
IsLocalization.AtPrime.not_isField | Mathlib.RingTheory.DedekindDomain.Dvr | ∀ (A : Type u_1) [inst : CommRing A] [IsDomain A] {P : Ideal A},
P ≠ ⊥ →
∀ [pP : P.IsPrime] (Aₘ : Type u_2) [inst_2 : CommRing Aₘ] [inst_3 : Algebra A Aₘ] [IsLocalization.AtPrime Aₘ P],
¬IsField Aₘ | true |
Finset.filter_true_of_mem | Mathlib.Data.Finset.Filter | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α}, (∀ x ∈ s, p x) → Finset.filter p s = s | true |
AddAut.conj_inv_apply | Mathlib.Algebra.Group.End | ∀ {G : Type u_3} [inst : AddGroup G] (g h : G), (Additive.toMul (AddAut.conj g))⁻¹ h = -g + h + g | true |
ModuleCat.MonModuleEquivalenceAlgebra.inverse._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] {X Y : AlgCat R} (f : X ⟶ Y),
CategoryTheory.IsMonHom (ModuleCat.ofHom (AlgCat.Hom.hom f).toLinearMap) | false |
Matroid.Dep.superset._auto_1 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax | false |
«term_×_» | Init.Notation | Lean.TrailingParserDescr | true |
ComplexShape.next_add | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_7} [inst : AddMonoid I] (c : ComplexShape I) [c.TensorSigns] (p q : I),
c.Rel p (c.next p) → c.next (p + q) = c.next p + q | true |
Std.Http.URI.EncodedString._sizeOf_inst | Std.Internal.Http.Data.URI.Encoding | (r : UInt8 → Bool) → SizeOf (Std.Http.URI.EncodedString r) | false |
CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse_obj_hom | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) (Y : CategoryTheory.Comma ((CategoryTheory.Under.forget c).com... | true |
IsIntegral.isAlgebraic | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] [Nontrivial R] {x : A},
IsIntegral R x → IsAlgebraic R x | true |
Lean.Lsp.instBEqDiagnosticCode | Lean.Data.Lsp.Diagnostics | BEq Lean.Lsp.DiagnosticCode | true |
Mathlib.Tactic.Order.ToInt.toInt_lt_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
Mathlib.Tactic.Order.ToInt.toInt val i < Mathlib.Tactic.Order.ToInt.toInt val j ↔ val i < val j | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_of_lt._simp_1_2 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.