name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Padic.limSeq._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : CauSeq ℚ_[p] ⇑padicNormE) (n : ℕ), ∃ r, padicNormE (↑f n - ↑r) < 1 / (↑n + 1) | false |
Std.Roo.toList | Init.Data.Range.Polymorphic.Iterators | {α : Type u} →
[inst : LT α] →
[DecidableLT α] →
[inst_2 : Std.PRange.UpwardEnumerable α] →
[Std.PRange.LawfulUpwardEnumerable α] → [Std.Rxo.IsAlwaysFinite α] → Std.Roo α → List α | true |
ByteSlice.stop_le_size_byteArray | Std.Data.ByteSlice | ∀ (xs : ByteSlice), xs.stop ≤ xs.byteArray.size | true |
NNReal.agmSequences_fst_le_agm | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal} (n : ℕ), (x.agmSequences y n).1 ≤ x.agm y | true |
Denumerable.lower'.eq_1 | Mathlib.Logic.Equiv.Finset | ∀ (x : ℕ), Denumerable.lower' [] x = [] | true |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorShiftTargetBlastArithShiftRightConst | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.ShiftTarget fun {len} =>
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst | true |
Lean.Meta.Match.Example.toMessageData | Lean.Meta.Match.Basic | Lean.Meta.Match.Example → Lean.MessageData | true |
riemannZeta_ne_zero_of_one_le_re | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ ⦃s : ℂ⦄, 1 ≤ s.re → riemannZeta s ≠ 0 | true |
OrderIso.symm_apply_eq | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x : α} {y : β}, e.symm y = x ↔ y = e x | true |
Aesop.CasesTarget.decl.injEq | Aesop.RuleTac.Basic | ∀ (decl decl_1 : Lean.Name), (Aesop.CasesTarget.decl decl = Aesop.CasesTarget.decl decl_1) = (decl = decl_1) | true |
Lean.Lsp.DocumentChange._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.DocumentChange → ℕ | false |
Algebra.Generators.Hom.toExtensionHom_toRingHom | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra R R']
... | true |
ContinuousMap.instNonAssocRingOfIsTopologicalRing | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : NonAssocRing β] → [IsTopologicalRing β] → NonAssocRing C(α, β) | true |
Std.TreeSet.Raw.min? | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet.Raw α cmp → Option α | true |
Std.DHashMap.Internal.Raw₀.Const.getKeyD_insertManyIfNewUnit_emptyWithCapacity_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {l : List α} {k k' fallback : α},
(k == k') = true →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l →
(↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity l)).ge... | true |
SimpleGraph.ConnectedComponent.iso_inv_image_comp_eq_iff_eq_map | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {φ : G ≃g G'} {v' : V'}
{C : G.ConnectedComponent},
G.connectedComponentMk (φ.symm v') = C ↔
G'.connectedComponentMk v' = SimpleGraph.ConnectedComponent.map (RelIso.toRelEmbedding φ).toRelHom C | true |
RootPairing.toPerfPair_comp_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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),
⇑P.toPerfPair ∘ ⇑P.root = P.root' | true |
ContMDiffMap.addGroup._proof_2 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : Topologi... | false |
Std.Iterators.Finite.recOn | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{motive : Std.Iterators.Finite α m → Sort u} →
(t : Std.Iterators.Finite α m) → ((wf : WellFounded Std.IterM.IsPlausibleSuccessorOf) → motive ⋯) → motive t | false |
_private.Lean.Meta.Sym.InferType.0.Lean.Meta.Sym.getLevel.match_1 | Lean.Meta.Sym.InferType | (motive : Option Lean.Level → Sort u_1) →
(x : Option Lean.Level) → ((u : Lean.Level) → motive (some u)) → ((x : Option Lean.Level) → motive x) → motive x | false |
lpPiLpₗᵢ._proof_2 | Mathlib.Analysis.Normed.Lp.LpEquiv | ∀ {α : Type u_3} (E : α → Type u_2) [inst : (i : α) → NormedAddCommGroup (E i)] (𝕜 : Type u_1)
[inst_1 : NontriviallyNormedField 𝕜] [inst_2 : (i : α) → NormedSpace 𝕜 (E i)] (i : α), IsBoundedSMul 𝕜 (E i) | false |
CategoryTheory.Functor.preservesFiniteProductsOfAdditive | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[F.Additive], CategoryTheory.Limits.PreservesFiniteProducts F | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_obj_obj_X | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
(A : CategoryTheory.CommMon (CategoryTheory.Functor C D)) (X : C),
((CategoryTheory.Monoidal.CommMonFunct... | true |
Int.instStarOrderedRing | Mathlib.Data.Int.Star | StarOrderedRing ℤ | true |
Multiset.mem_range._simp_1 | Mathlib.Data.Multiset.Range | ∀ {m n : ℕ}, (m ∈ Multiset.range n) = (m < n) | false |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
{s : String.Slice} → String.Slice.SplitIterator pat s → Option (Std.Iter (String.Slice.Pattern.SearchStep s)) | true |
ProbabilityTheory.instIsGaussianMapNeg | Mathlib.Probability.Distributions.Gaussian.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{μ : MeasureTheory.Measure E} [ProbabilityTheory.IsGaussian μ],
ProbabilityTheory.IsGaussian (MeasureTheory.Measure.map (fun x => -x) μ) | true |
_private.Init.Data.Vector.Extract.0.Vector.extract_set._proof_1 | Init.Data.Vector.Extract | ∀ {n i j k : ℕ}, ¬k < i → k < min j n → ¬k - i < min j n - i → False | false |
MonoidHomClass.toOneHomClass | Mathlib.Algebra.Group.Hom.Defs | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} {inst : MulOne M} {inst_1 : MulOne N}
{inst_2 : FunLike F M N} [self : MonoidHomClass F M N], OneHomClass F M N | true |
Lean.Elab.Tactic.GuardExpr.MatchKind._sizeOf_1 | Lean.Elab.Tactic.Guard | Lean.Elab.Tactic.GuardExpr.MatchKind → ℕ | false |
Float.toStringFull._sparseCasesOn_1 | Batteries.Lean.Float | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.getConstInfoNoEx? | Lean.Meta.WHNF | Lean.Name → Bool → Lean.MetaM (Option Lean.ConstantInfo) | true |
MvPowerSeries.rename | Mathlib.RingTheory.MvPowerSeries.Rename | {σ : Type u_1} →
{τ : Type u_2} →
{R : Type u_4} →
(f : σ → τ) → [inst : CommSemiring R] → [Filter.TendstoCofinite f] → MvPowerSeries σ R →ₐ[R] MvPowerSeries τ R | true |
FirstOrder.Language.Prestructure.ctorIdx | Mathlib.ModelTheory.Quotients | {L : FirstOrder.Language} → {M : Type u_1} → {s : Setoid M} → L.Prestructure s → ℕ | false |
LinearEquiv.ofLeftInverse._proof_1 | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_3} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_1} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {f : M →ₛₗ[σ₁₂] M₂} [inst_4 : RingHomInvPair σ₁₂ σ₂₁] (x y : M),
f.... | false |
Fin.attachFin_Ioo_eq_Ioi | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a : Fin n), (Finset.Ioo (↑a) n).attachFin ⋯ = Finset.Ioi a | true |
ProjectiveSpectrum.basicOpen | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubmonoidClass σ A] →
(𝒜 : ℕ → σ) → [inst_3 : GradedRing 𝒜] → A → TopologicalSpace.Opens (ProjectiveSpectrum 𝒜) | true |
CategoryTheory.nerveEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.ComposableArrows C 0),
CategoryTheory.ComposableArrows.mk₀ (f.obj ⟨0, CategoryTheory.nerveEquiv._proof_2⟩) = f | false |
Std.Iterators.Types.Zip.instFinitenessRelation₂._proof_5 | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type u_1 → Type u_2} {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type u_1}
[inst_1 : Std.Iterator α₂ m β₂] [inst_2 : Std.Iterators.Productive α₁ m] [inst_3 : Std.Iterators.Finite α₂ m],
WellFounded (Std.Iterators.Types.Zip.Rel₂ m) | false |
String.Slice.RevByteIterator._sizeOf_inst | Init.Data.String.Iterate | SizeOf String.Slice.RevByteIterator | false |
PartialFun.Iso.mk_inv | Mathlib.CategoryTheory.Category.PartialFun | ∀ {α β : PartialFun} (e : α ≃ β) (x : β), (PartialFun.Iso.mk e).inv x = ↑(some (e.symm x)) | true |
Batteries.Tactic.«tacticOn_goal-_=>_» | Batteries.Tactic.PermuteGoals | Lean.ParserDescr | true |
Lean.EffectiveImport.mk.injEq | Lean.Environment | ∀ (toImport : Lean.Import) (irPhases : Lean.IRPhases) (toImport_1 : Lean.Import) (irPhases_1 : Lean.IRPhases),
({ toImport := toImport, irPhases := irPhases } = { toImport := toImport_1, irPhases := irPhases_1 }) =
(toImport = toImport_1 ∧ irPhases = irPhases_1) | true |
SimpleGraph.Walk.length_ofDarts | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {l : List G.Dart} (hne : l ≠ []) (hchain : List.IsChain G.DartAdj l),
(SimpleGraph.Walk.ofDarts l hne hchain).length = l.length | true |
Computation.Bind.g.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (a : β), Computation.Bind.g (Sum.inl a) = Sum.inl a | true |
_private.Lean.Server.InfoUtils.0.Lean.Elab.Info.fmtHover?.isAtomicFormat._sparseCasesOn_1 | Lean.Server.InfoUtils | {motive : Std.Format → Sort u} →
(t : Std.Format) →
((a : String) → motive (Std.Format.text a)) →
((a : Std.Format) → (behavior : Std.Format.FlattenBehavior) → motive (a.group behavior)) →
((indent : ℤ) → (f : Std.Format) → motive (Std.Format.nest indent f)) →
((a : ℕ) → (a_1 : Std.Format)... | false |
instMaxInt8 | Init.Data.SInt.Basic | Max Int8 | true |
Finset.exists_mem_image₂ | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
{p : γ → Prop}, (∃ z ∈ Finset.image₂ f s t, p z) ↔ ∃ x ∈ s, ∃ y ∈ t, p (f x y) | true |
MDifferentiableAt.fst | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
BooleanSubalgebra.mk_le_mk._simp_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L M : Sublattice α} (hL_compl : ∀ {a : α}, a ∈ L.carrier → aᶜ ∈ L.carrier)
(hL_bot : ⊥ ∈ L.carrier) (hM_compl : ∀ {a : α}, a ∈ M.carrier → aᶜ ∈ M.carrier) (hM_bot : ⊥ ∈ M.carrier),
({ toSublattice := L, compl_mem' := hL_compl, bot_mem' := hL_bot } ≤
{ toSublattice :... | false |
CategoryTheory.MorphismProperty.IsStableUnderLimitsOfShape.rec | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] →
{motive : W.IsStableUnderLimitsOfShape J → Sort u_2} →
((condition :
∀ (X₁ X₂ : CategoryTheo... | false |
USize.toUSize_toISize | Init.Data.SInt.Lemmas | ∀ (x : USize), x.toISize.toUSize = x | true |
Aesop.instInhabitedTraceOption | Aesop.Tracing | Inhabited Aesop.TraceOption | true |
_private.Init.NotationExtra.0.Lean.expandExplicitBindersAux.loop | Init.NotationExtra | Lean.Syntax →
(idents : Array Lean.Syntax) → Option Lean.Syntax → (i : ℕ) → i ≤ idents.size → Lean.Syntax → Lean.MacroM Lean.Syntax | true |
_private.Mathlib.NumberTheory.Padics.Hensel.0.soln_gen | Mathlib.NumberTheory.Padics.Hensel | {p : ℕ} →
[inst : Fact (Nat.Prime p)] →
{R : Type u_1} →
[inst_1 : CommSemiring R] →
[inst_2 : Algebra R ℤ_[p]] →
{F : Polynomial R} →
{a : ℤ_[p]} → ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2 → ℤ_[p] | true |
ChainComplex.next_nat_succ | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (i : ℕ), (ComplexShape.down ℕ).next (i + 1) = i | true |
Lean.Syntax.ctorElim | Init.Prelude | {motive_1 : Lean.Syntax → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Syntax) → ctorIdx = t.ctorIdx → Lean.Syntax.ctorElimType ctorIdx → motive_1 t | false |
RingCat.limitRing._proof_42 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J RingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget RingCat))).pt), -a + a = 0 | false |
Stream'.map | Mathlib.Data.Stream.Defs | {α : Type u} → {β : Type v} → (α → β) → Stream' α → Stream' β | true |
Rat.mkRat_pow | Mathlib.Algebra.Ring.Rat | ∀ (num den n : ℕ), mkRat (↑num) den ^ n = mkRat (↑num ^ n) (den ^ n) | true |
Equiv.Perm.sumCongrHom | Mathlib.Algebra.Group.End | (α : Type u_7) → (β : Type u_8) → Equiv.Perm α × Equiv.Perm β →* Equiv.Perm (α ⊕ β) | true |
Multiset.decidableDforallMultiset.match_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {m : Multiset α} (motive : (x : { x // x ∈ m }) → x ∈ m.attach → Prop) (x : { x // x ∈ m })
(x_1 : x ∈ m.attach), (∀ (_a : α) (_ha : _a ∈ m) (x : ⟨_a, _ha⟩ ∈ m.attach), motive ⟨_a, _ha⟩ x) → motive x x_1 | false |
Pell.yn_modEq_two | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.yn a1 n ≡ n [MOD 2] | true |
Finset.mem_inv_smul_finset_iff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {s : Finset β}
{a : α} {b : β}, b ∈ a⁻¹ • s ↔ a • b ∈ s | true |
_private.Mathlib.Tactic.FunProp.FunctionData.0.Mathlib.Meta.FunProp.MaybeFunctionData.get.match_1 | Mathlib.Tactic.FunProp.FunctionData | (motive : Mathlib.Meta.FunProp.MaybeFunctionData → Sort u_1) →
(fData : Mathlib.Meta.FunProp.MaybeFunctionData) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.letE f)) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.lam f)) →
((d : Mathlib.Meta.FunProp.Functi... | false |
FractionalIdeal.isFractional_of_le | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{I : Submodule R P} {J : FractionalIdeal S P}, I ≤ ↑J → IsFractional S I | true |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.Data.Atom.mk.noConfusion | Lean.Elab.DocString.Builtin.Keywords | {P : Sort u} →
{name category name' category' : Lean.Name} →
{ name := name, category := category } = { name := name', category := category' } →
(name = name' → category = category' → P) → P | false |
Module.Basis.linearMap_repr_apply | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} {ι₁ : Type u_6} {ι₂ : Type u_7} [inst : CommSemiring R]
[inst_1 : AddCommMonoid M₁] [inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂]
[inst_5 : Fintype ι₁] [inst_6 : Fintype ι₂] [inst_7 : DecidableEq ι₁] (b₁ : Module.Basis ι₁ R M₁)
(b₂ : Mod... | true |
Finset.mem_image₂_iff | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
{a : α} {b : β}, Function.Injective2 f → (f a b ∈ Finset.image₂ f s t ↔ a ∈ s ∧ b ∈ t) | true |
OreLocalization.instAddCommGroup | Mathlib.RingTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : Monoid R] →
{S : Submonoid R} →
[inst_1 : OreLocalization.OreSet S] →
{X : Type u_2} →
[inst_2 : AddCommGroup X] → [inst_3 : DistribMulAction R X] → AddCommGroup (OreLocalization S X) | true |
Set.powersetCard.mem_ofFinEmbEquiv_iff_mem_range._simp_1 | Mathlib.Order.Hom.PowersetCard | ∀ {n : ℕ} {I : Type u_1} [inst : LinearOrder I] (f : Fin n ↪o I) (i : I),
(i ∈ Set.powersetCard.ofFinEmbEquiv f) = (i ∈ Set.range ⇑f) | false |
norm_prod_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {E : Type u_5} [inst : SeminormedCommGroup E] (s : Finset ι) (f : ι → E),
‖∏ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖ | true |
WeierstrassCurve.valuation_Δ_aux.congr_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W W_1 : WeierstrassCurve K),
W = W_1 → WeierstrassCurve.valuation_Δ_aux R W = WeierstrassCurve.valuation_Δ_aux R W_1 | true |
TypeVec.Arrow.inhabited | Mathlib.Data.TypeVec | {n : ℕ} → (α : TypeVec.{u_1} n) → (β : TypeVec.{u_2} n) → [(i : Fin2 n) → Inhabited (β i)] → Inhabited (α.Arrow β) | true |
CategoryTheory.Limits.MulticospanIndex.sections | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} → CategoryTheory.Limits.MulticospanIndex J (Type u) → Type (max u u_1) | true |
_private.Mathlib.Algebra.Ring.Int.Parity.0.Int.not_odd_zero._proof_1_1 | Mathlib.Algebra.Ring.Int.Parity | ¬Odd 0 | false |
Nat.mem_primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {n p : ℕ}, p ∈ n.primeFactors ↔ Nat.Prime p ∧ p ∣ n ∧ n ≠ 0 | true |
HopfAlgCat.instMonoidalBialgCatForget₂BialgHomCarrierCarrier._proof_1 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R)))
(CategoryTheory.Functor.OplaxMonoidal.η (CategoryTheory.forget₂ (HopfAlgCat R) (BialgCat R))) =
CategoryTheory.CategoryStruct.id (Categor... | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.sum_ofPairwiseDisjoint_eq_sum._proof_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {parts : Finset α}
{X : Type u_2} [inst_3 : AddCommMonoid X] {f : α → X}, f ⊥ = 0 → ∀ a ∈ {⊥}, a ∉ parts.erase ⊥ → f a = 0 | false |
Std.DHashMap.Internal.Raw₀.Const.getD_union | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β},
Std.DHashMap.Internal.Raw₀.Const.getD (m₁.union m₂) k fallback =
Std.DHashMap.Internal.Raw₀.... | true |
LinearMap.separatingLeft_of_det_ne_zero | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {m : Type u_12} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m]
[IsDomain R] [inst_4 : AddCommMonoid M₁] [inst_5 : Module R M₁] (b : Module.Basis m R M₁) {B : M₁ →ₗ[R] M₁ →ₗ[R] R},
((LinearMap.toMatrix₂ b b) B).det ≠ 0 → B.SeparatingLeft | true |
LinearEquiv.multilinearMapCongrLeft_apply | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₁' : ι → Type v₁'} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (M₁' ... | true |
Lean.Lsp.CallHierarchyOutgoingCall.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.CallHierarchyOutgoingCall → Lean.Lsp.CallHierarchyOutgoingCall → Sort u | false |
Vector.mapFinIdxM.eq_1 | Init.Data.Vector.MapIdx | ∀ {n : ℕ} {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (xs : Vector α n)
(f : (i : ℕ) → α → i < n → m β), xs.mapFinIdxM f = Vector.mapFinIdxM.map xs f n 0 ⋯ (Vector.cast ⋯ #v[]) | true |
MulZeroClass.mk | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
[toMul : Mul M₀] → [toZero : Zero M₀] → (∀ (a : M₀), 0 * a = 0) → (∀ (a : M₀), a * 0 = 0) → MulZeroClass M₀ | true |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy._simp_9 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
ProbabilityTheory.indep_bot_left | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω}
[MeasureTheory.IsZeroOrProbabilityMeasure μ], ProbabilityTheory.Indep ⊥ m' μ | true |
PadicInt.mem_nonunits | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]}, z ∈ nonunits ℤ_[p] ↔ ‖z‖ < 1 | true |
CategoryTheory.StrictlyUnitaryPseudofunctor.comp | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Bicategory D] →
CategoryTheory.StrictlyUnitaryPseudofunctor B C →
CategoryTheory.StrictlyUnitaryPseudofunctor C... | true |
_private.Mathlib.Util.Superscript.0.Mathlib.Tactic.Superscript.scriptFnNoAntiquot._proof_1 | Mathlib.Util.Superscript | ∀ (newStr : String), newStr.rawEndPos ≤ newStr.rawEndPos | false |
Finset.card_sdiff_of_subset | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s t : Finset α} [inst : DecidableEq α], s ⊆ t → (t \ s).card = t.card - s.card | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α fun x => Unit),
t.Balanced → ∀ (__s : Std.DTreeMap.Internal.Impl.Const.IteratedUnitInsertionInto t), (↑__s).Balanced | false |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.EmbedFmt.recOn | Lean.Widget.InteractiveDiagnostic | {motive : Lean.Widget.EmbedFmt✝ → Sort u} →
(t : Lean.Widget.EmbedFmt✝) →
((ctx : Lean.Elab.ContextInfo) →
(infos : Std.TreeMap ℕ Lean.Elab.Info compare) → motive (Lean.Widget.EmbedFmt.code✝ ctx infos)) →
((ctx : Lean.Elab.ContextInfo) →
(lctx : Lean.LocalContext) → (g : Lean.MVarId) → mot... | false |
_private.Mathlib.Analysis.Asymptotics.Completion.0.Asymptotics.isBigO_completion_left._simp_1_1 | Mathlib.Analysis.Asymptotics.Completion | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =O[l] g = ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | false |
_private.Mathlib.Data.List.Chain.0.List.IsChain.backwards_induction._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} (p : α → Prop) (l : List α),
(∀ (lne : l ≠ []), p (l.getLast lne)) →
((∀ (lne : l.reverse ≠ []), p (l.reverse.head lne)) → ∀ i ∈ l.reverse, p i) → ∀ i ∈ l, p i | false |
SimplexCategory.isSkeletonOf | Mathlib.AlgebraicTopology.SimplexCategory.Basic | CategoryTheory.IsSkeletonOf NonemptyFinLinOrd SimplexCategory SimplexCategory.skeletalFunctor | true |
IsLocalHomeomorph.continuous | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f → Continuous f | true |
CategoryTheory.Equivalence.toOrderIso | Mathlib.CategoryTheory.Category.Preorder | {X : Type u} → {Y : Type v} → [inst : PartialOrder X] → [inst_1 : PartialOrder Y] → (X ≌ Y) → X ≃o Y | true |
CategoryTheory.Free.instLinear | Mathlib.Algebra.Category.ModuleCat.Adjunctions | (R : Type u_1) →
[inst : CommRing R] →
(C : Type u) → [inst_1 : CategoryTheory.Category.{v, u} C] → CategoryTheory.Linear R (CategoryTheory.Free R C) | true |
NonUnitalAlgHom.instNonUnitalAlgSemiHomClass | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} [inst : Monoid R] [inst_1 : Monoid S] {φ : R →* S} {A : Type v} {B : Type w}
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : DistribMulAction R A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction S B], NonUnitalAlgSemiHomClass (A →ₛₙₐ[φ] B) φ A B | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.