name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames | Lean.Meta.Tactic.ExposeNames | Lean.MetaM Lean.LocalContext | Returns a copy of the local context in which all declarations have clear, accessible names. | true |
List.cons.inj | Init.Core | ∀ {α : Type u} {head : α} {tail : List α} {head_1 : α} {tail_1 : List α},
head :: tail = head_1 :: tail_1 → head = head_1 ∧ tail = tail_1 | null | true |
Empty.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | BorelSpace Empty | null | true |
QuaternionAlgebra.Basis.k_compHom | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {c₁ c₂ c₃ : R} (q : QuaternionAlgebra.Basis A c₁ c₂ c₃) (F : A →ₐ[R] B),
(q.compHom F).k = F q.k | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w : ℕ) (eaig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit)
(evec : eaig.RefVec w) (heaig : aig.decls.size ≤ { aig := eaig, vec := evec }.aig.decls.size),
(↑⟨{ aig := eaig, vec := evec }, heaig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastCpop (↑⟨{ aig ... | null | false |
Std.Time.Month.Ordinal.january | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal | The ordinal value representing the month of January.
| true |
AddGroupSeminorm.instIsZeroApplyReal | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E], IsZeroApply (AddGroupSeminorm E) E ℝ | null | true |
WithBot.instSemiring | Mathlib.Algebra.Order.Ring.WithTop | {α : Type u_1} →
[DecidableEq α] →
[inst : Semiring α] → [Subsingleton (AddUnits α)] → [NoZeroDivisors α] → [Nontrivial α] → Semiring (WithBot α) | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isRevMatch_sliceFrom_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch pat pos =
String.Slice.Pattern.Model.PatternModel.Matches pat (s.sliceFrom pos).copy | null | false |
Aesop.RuleResult.ctorIdx | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {w : ℕ}, ∀ curr < w, curr + 1 ≤ w | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.eval.match_17 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(rα : Q(CommRing «$α»)) →
(expr expr_1 : Q(«$α»)) →
(motive :
Mathlib.Tactic.Ring.Common.Result (Mathlib.Tactic.Ring.Common.ExSum bt sα) q(«$expr» - «$expr_1») →
... | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.LeftHomologyData) [CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂]
(wi : CategoryTheory.CategoryStruct.comp (CategoryTheory... | null | false |
LinearMap.tensorEqLocusInv._proof_2 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_3} [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
{P : Type u_4} [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup P] [inst_5 : Module R N] [inst_6 : Module R P]
(f g : N →ₗ[R] P) [Module.Flat R M], Function.Injective ⇑(LinearMap.lTensor M (f.eqLocus g... | null | false |
Subsemiring.instTop._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R], 0 ∈ ⊤.carrier | null | false |
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
RootPairing.Hom.comp._proof_3 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_6} {R : Type u_4} {M : Type u_7} {N : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₁ : Type u_8} {M₁ : Type u_9} {N₁ : Type u_5}
{ι₂ : Type u_2} {M₂ : Type u_10} {N₂ : Type u_3} [inst_5 : AddCommGroup M₁] [inst_6 : Modu... | null | false |
SchwartzMap.compCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], RingHomIsometric (RingHom.id 𝕜) | null | false |
CategoryTheory.MorphismProperty.precoverage_monotone | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P ≤ Q → P.precoverage ≤ Q.precoverage | null | true |
RingHom.formallyEtale_algebraMap | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale ↔ Algebra.FormallyEtale R S | null | true |
_private.Mathlib.Data.Nat.Choose.Lucas.0.Choose.gcd_choose_eq_one_of_not_isPrimePow._simp_1_2 | Mathlib.Data.Nat.Choose.Lucas | ∀ {n a : ℕ}, (n ∣ a) = (a ≡ 0 [MOD n]) | null | false |
Order.Ideal.coe_sup_eq | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, ↑(I ⊔ J) = {x | ∃ i ∈ I, ∃ j ∈ J, x = i ⊔ j} | null | true |
SSet.splitting._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.Splitting | ∀ (X : SSet) (n : ℕ),
Nonempty
(CategoryTheory.Limits.IsColimit
(CategoryTheory.SimplicialObject.Splitting.cofan' (fun n => ↑(X.nonDegenerate n)) X
(fun n => TypeCat.ofHom Subtype.val) (Opposite.op { len := n }))) | null | false |
ContinuousMultilinearMap.smulRight_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [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 : TopologicalSpace R] [inst_6 : (i : ι) → TopologicalSpace (M₁ i)]
[inst_7 : TopologicalSp... | null | true |
Int.negOnePow_two_mul_add_one | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), (2 * n + 1).negOnePow = -1 | null | true |
Std.Time.FormatPart.noConfusionType | Std.Time.Format.Basic | Sort u → Std.Time.FormatPart → Std.Time.FormatPart → Sort u | null | false |
Nat.testBit_ofBits_lt | Batteries.Data.Nat.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ) (h : i < n), (Nat.ofBits f).testBit i = f ⟨i, h⟩ | null | true |
Std.Do.Internal.MayReturn.mk._flat_ctor | Std.Do.Internal.Ensures.Def | ∀ {m : Type u → Type v} [inst : Bind m] {α : Type u} {x : m α} {a : α},
(∀ {P : α → Prop}, Std.Do.Internal.Ensures P x → P a) → Std.Do.Internal.MayReturn x a | null | false |
HahnSeries.leadingCoeff_abs | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Γ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff| | null | true |
isOpenMap_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_2} {σ : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) | null | true |
SimpleGraph.TripartiteFromTriangles.NoAccidental.mk._flat_ctor | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {t : Finset (α × β × γ)},
(∀ ⦃a a' : α⦄ ⦃b b' : β⦄ ⦃c c' : γ⦄, (a', b, c) ∈ t → (a, b', c) ∈ t → (a, b, c') ∈ t → a = a' ∨ b = b' ∨ c = c') →
SimpleGraph.TripartiteFromTriangles.NoAccidental t | null | false |
Int64.right_eq_add | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, b = a + b ↔ a = 0 | null | true |
Std.TreeMap.Raw.mem_union_of_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ → k ∈ t₁ ∪ t₂ | null | true |
_private.Mathlib.Data.Set.Lattice.Indexed.0.Set.forall_mem_iUnion._simp_1_2 | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.pow_of_coprime._proof_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M},
IsPrimitiveRoot ζ k → ∀ (i : ℕ), i.Coprime k → IsPrimitiveRoot (ζ ^ i) k | null | false |
MvPowerSeries.one_le_order_iff_constCoeff_eq_zero | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {f : MvPowerSeries σ R},
1 ≤ f.order ↔ MvPowerSeries.constantCoeff f = 0 | null | true |
CompletelyDistribLattice.top_sdiff | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [self : CompletelyDistribLattice α] (a : α), ⊤ \ a = ￢a | `⊤ \ a` is `￢a` | true |
IsInvariantSubring.toMulSemiringAction._proof_1 | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[IsInvariantSubring M S] (m : M) (x : ↥S), m • ↑x ∈ S | null | false |
Std.Net.SocketAddress | Std.Net.Addr | Type | Either a `SocketAddressV4` or `SocketAddressV6`.
| true |
IsClosedMap.specializingMap | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → SpecializingMap f | null | true |
CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex)
(n : ℕ) (g : P.complex.X n ⟶ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) ⟶ Q.complex.X (n + 2)... | null | true |
CategoryTheory.Functor.IsEventuallyConstantFrom.isIso_ι_of_isColimit' | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J},
F.IsEventuallyConstantFrom i₀ →
∀ [CategoryTheory.IsFiltered J] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
... | More general version of `isIso_ι_of_isColimit`. | true |
PUnit.inv_eq | Mathlib.Algebra.Group.PUnit | ∀ (x : PUnit.{u_1 + 1}), x⁻¹ = PUnit.unit | null | true |
CategoryTheory.Functor.mapCocone₂_pt | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5,... | null | true |
CauSeq.equiv_lim | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] [inst_5 : CauSeq.IsComplete β abv] (s : CauSeq β abv),
s ≈ CauSeq.const abv s.lim | null | true |
MontelSpace.rec | Mathlib.Analysis.LocallyConvex.Montel | {𝕜 : Type u_3} →
{E : Type u_4} →
[inst : SeminormedRing 𝕜] →
[inst_1 : Zero E] →
[inst_2 : SMul 𝕜 E] →
[inst_3 : TopologicalSpace E] →
{motive : MontelSpace 𝕜 E → Sort u} →
((heine_borel : ∀ (s : Set E), IsClosed s → Bornology.IsVonNBounded 𝕜 s → IsCompact s... | null | false |
Subgroup.pi | Mathlib.Algebra.Group.Subgroup.Basic | {η : Type u_5} →
{f : η → Type u_6} → [inst : (i : η) → Group (f i)] → Set η → ((i : η) → Subgroup (f i)) → Subgroup ((i : η) → f i) | A version of `Set.pi` for subgroups. Given an index set `I` and a family of submodules
`s : Π i, Subgroup f i`, `pi I s` is the subgroup of dependent functions `f : Π i, f i` such that
`f i` belongs to `pi I s` whenever `i ∈ I`. | true |
Set.zero_notMem_sub_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∉ s - t ↔ Disjoint s t | null | true |
MeasureTheory.Filtration.definition._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} →
{m : MeasurableSpace Ω} → [inst : PartialOrder ι] → MeasureTheory.Filtration ι m → MeasureTheory.Filtration ι m | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr | Process a `fType` of the form `{x : A} → B x`.
This method assume `fType` is a function type | true |
CategoryTheory.GrothendieckTopology.uliftYonedaOpCompCoyoneda_inv_app_app_hom_apply_hom_app_hom_apply | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] (X : Cᵒᵖ) (X_1 : CategoryTheory.Sheaf J (Type (max v' v)))
(a :
(((CategoryTheory.evaluation Cᵒᵖ (Type (max v v'))).comp
(((CategoryTheory.Functor.whiskeringRight (Categor... | null | true |
List.Subset.antisymm_of_sortedLT | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : PartialOrder α] {l₁ l₂ : List α}, l₁ ⊆ l₂ → l₂ ⊆ l₁ → l₁.SortedLT → l₂.SortedLT → l₁ = l₂ | null | true |
Aesop.GoalWithMVars.recOn | Aesop.Script.GoalWithMVars | {motive : Aesop.GoalWithMVars → Sort u} →
(t : Aesop.GoalWithMVars) →
((goal : Lean.MVarId) → (mvars : Std.HashSet Lean.MVarId) → motive { goal := goal, mvars := mvars }) → motive t | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.2484951916._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.comap_freeLocus_le._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A],
(algebraMap S A).comp (algebraMap R S) = algebraMap R A | null | false |
Std.ExtDTreeMap.getKey?_maxKey | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{he : t ≠ ∅}, t.getKey? (t.maxKey he) = some (t.maxKey he) | null | true |
Concept.extent_sup | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c d : Concept α β r),
(c ⊔ d).extent = lowerPolar r (c.intent ∩ d.intent) | **Alias** of `Concept.extent_max`. | true |
SimpleGraph.Subgraph._sizeOf_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → [SizeOf V] → G.Subgraph → ℕ | null | false |
Function.Surjective.addAction._proof_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_2} {α : Type u_3} {β : Type u_1} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : α → β),
Function.Surjective f → (∀ (c : M) (x : α), f (c +ᵥ x) = c +ᵥ f x) → ∀ (x y : M) (b : β), (x + y) +ᵥ b = x +ᵥ y +ᵥ b | null | false |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDeclAux.match_1 | Lean.Compiler.IR.EmitLLVM | (motive : Lean.IR.Decl → Sort u_1) →
(d : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(t : Lean.IR.IRType) →
(b : Lean.IR.FnBody) → (info : Lean.IR.DeclInfo) → motive (Lean.IR.Decl.fdecl f xs t b info)) →
((x : Lean.IR.Decl) → motive x) → motive d | null | false |
Matrix.center_eq_range | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_3} (R : Type u_5) [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommSemiring R],
Set.center (Matrix n n R) = Set.range ⇑(Matrix.scalar n) | For a commutative semiring `R`, the center of `Matrix n n R` is the range of `scalar n`
(i.e., the span of `{1}`). | true |
AddMonoidHom.range_eq_top_of_surjective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_6} [inst_1 : AddGroup N] (f : G →+ N),
Function.Surjective ⇑f → f.range = ⊤ | The range of a surjective `AddMonoid` homomorphism is the whole of the codomain. | true |
Real.convergent_zero | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ (ξ : ℝ), ξ.convergent 0 = ↑⌊ξ⌋ | The zeroth convergent of `ξ` is `⌊ξ⌋`. | true |
CategoryTheory.Bicategory.conjugateIsoEquiv_apply_inv | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {l₁ l₂ : c ⟶ d} {r₁ r₂ : d ⟶ c}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) (adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (α : l₂ ≅ l₁),
((CategoryTheory.Bicategory.conjugateIsoEquiv adj₁ adj₂) α).inv =
(CategoryTheory.Bicategory.conjug... | null | true |
mapsTo_gaugeRescale_closure | Mathlib.Analysis.Convex.GaugeRescale | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul ℝ E] {s t : Set E},
Convex ℝ s → s ∈ nhds 0 → Convex ℝ t → 0 ∈ t → Absorbent ℝ t → Set.MapsTo (gaugeRescale s t) (closure s) (closure t) | null | true |
Std.HashMap.mem_alter_of_beq | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : Option β → Option β}, (k == k') = true → (k' ∈ m.alter k f ↔ (f m[k]?).isSome = true) | null | true |
Monotone.forall | Mathlib.Order.BoundedOrder.Monotone | ∀ {α : Type u} {β : Type v} [inst : Preorder α] {P : β → α → Prop},
(∀ (x : β), Monotone (P x)) → Monotone fun y => ∀ (x : β), P x y | null | true |
Std.Time.Duration.mk._flat_ctor | Std.Time.Duration | (second : Std.Time.Second.Offset) →
(nano : Std.Time.Nanosecond.Span) → second.val ≥ 0 ∧ ↑nano ≥ 0 ∨ second.val ≤ 0 ∧ ↑nano ≤ 0 → Std.Time.Duration | null | false |
FBinopElab.instInhabitedSRec | Mathlib.Tactic.FBinop | Inhabited FBinopElab.SRec | null | true |
CategoryTheory.Meq.congr_apply | Mathlib.CategoryTheory.Sites.ConcreteSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {FD : D → D → Type u_1} {CD : D → Type t}
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)] [inst_3 : CategoryTheory.ConcreteCategory D FD] {X : C}
{P ... | null | true |
MonCat.limitMonoid._aux_8 | Mathlib.Algebra.Category.MonCat.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J MonCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget MonCat)).sections] →
ℕ →
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget MonCat))).pt →
... | null | false |
HomologicalComplex.instIsEquivalenceOppositeSymmOpFunctor | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} (V : Type u_2) [inst : CategoryTheory.Category.{v_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V], (HomologicalComplex.opFunctor V c).IsEquivalence | null | true |
CategoryTheory.Limits.FormalCoproduct.cechFunctor | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteProducts C] →
CategoryTheory.Functor (CategoryTheory.Limits.FormalCoproduct C)
(CategoryTheory.SimplicialObject (CategoryTheory.Limits.FormalCoproduct C)) | The functor `FormalCoproduct C ⥤ SimplicialObject (FormalCoproduct C)`
which sends a formal coproduct to its Cech object. | true |
Mathlib.Tactic.Conv.Path.brecOn | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
(t : Mathlib.Tactic.Conv.Path) →
((t : Mathlib.Tactic.Conv.Path) → Mathlib.Tactic.Conv.Path.below t → motive t) → motive t | null | false |
Std.ExtDHashMap.get_union_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ | null | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Expr →
Lean.Expr →
Lean.Meta.Grind.Arith.Linear.LinExpr →
Lean.Meta.Grind.Arith.Linear.LinExpr → Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof | null | true |
CategoryTheory.Bicategory.Adjunction.mk.injEq | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(unit : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g)
(counit : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b)
(left_triangle :
autoParam
(CategoryTheory.Bi... | null | true |
Mathlib.Tactic.ITauto.Proof.em | Mathlib.Tactic.ITauto | Bool → Lean.Name → Mathlib.Tactic.ITauto.Proof | * `classical = false`: `(p: Decidable A) ⊢ A ∨ ¬A`
* `classical = true`: `(p: Prop) ⊢ p ∨ ¬p`
| true |
Finset.isPWO_sup | Mathlib.Order.WellFoundedSet | ∀ {ι : Type u_1} {α : Type u_2} [inst : Preorder α] (s : Finset ι) {f : ι → Set α},
(s.sup f).IsPWO ↔ ∀ i ∈ s, (f i).IsPWO | null | true |
Lean.NameMapExtension.find? | Batteries.Lean.NameMapAttribute | {α : Type} → Lean.NameMapExtension α → Lean.Environment → Lean.Name → Option α | Look up a value in the given extension in the environment. | true |
Std.Iter.foldM_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.IteratorLoop α Id n] [inst_9 : Std.IteratorLoop α Id o... | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence._unary._proof_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : ByteArray) (stackPos : ℕ) (hst : stackPos < pat.size) (guess : ℕ) (hg : guess < stackPos)
(this : String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < guess),
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < stackPos | null | false |
DiscreteConvolution.add_addRingConvolution | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {R : Type u_7} [inst : AddMonoid M] [inst_1 : NonUnitalNonAssocSemiring R]
[inst_2 : TopologicalSpace R] [T2Space R] [ContinuousAdd R] (f g h : M → R),
DiscreteConvolution.AddConvolutionExists (LinearMap.mul ℕ R) f h →
DiscreteConvolution.AddConvolutionExists (LinearMap.mul ℕ R) g h →
Dis... | null | true |
CategoryTheory.ComonObj.comul | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} → [self : CategoryTheory.ComonObj X] → X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj X X | The comultiplication morphism of a comonoid object. | true |
_private.Batteries.Data.List.Lemmas.0.List.swap_swap._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i j : ℕ} (i_1 : ℕ),
i_1 + 1 ≤ ((xs.swap i j).swap i j).length → i_1 < (xs.swap i j).length | null | false |
PointedCone.mem_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] {K : PointedCone 𝕜 E} {a : E}, a ∈ K.closure ↔ a ∈ closure ↑K | null | true |
Prod.instBornology._proof_1 | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β],
(Bornology.cobounded α).coprod (Bornology.cobounded β) ≤ Filter.cofinite | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Removal.0.Mathlib.Meta.Positivity.evalTriangleRemovalBound.match_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(pα? : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((val : Q(PartialOrder «$α»)) → motive (some val)) → motive pα? | null | false |
Lean.Compiler.LCNF.instTraverseFVarArg | Lean.Compiler.LCNF.FVarUtil | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.TraverseFVar (Lean.Compiler.LCNF.Arg pu) | null | true |
Nat.mem_divisors_self | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ), n ≠ 0 → n ∈ n.divisors | null | true |
CochainComplex.mappingCone.δ_descCochain._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n : ℤ} (n' : ℤ), n + 1 = n' → 1 + n = n' | null | false |
AlgebraicGeometry.Scheme.Cover.Over | Mathlib.AlgebraicGeometry.Cover.Over | (S : AlgebraicGeometry.Scheme) →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[P.IsStableUnderBaseChange] →
[AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X : AlgebraicGeometry.Scheme} →
[X.Over S] → AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Schem... | A `P`-cover of a scheme `X` over `S` is a cover, where the components are over `S` and the
component maps commute with the structure morphisms. | true |
ValuativeRel.ValueGroupWithZero.exact | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x y : R} {t s : ↥(ValuativeRel.posSubmonoid R)},
ValuativeRel.ValueGroupWithZero.mk x t = ValuativeRel.ValueGroupWithZero.mk y s → x * ↑s ≤ᵥ y * ↑t ∧ y * ↑t ≤ᵥ x * ↑s | null | true |
Ordering.swap.eq_3 | Std.Data.DTreeMap.Internal.Model | Ordering.gt.swap = Ordering.lt | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.