name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TopologicalSpace.Opens.overEquivalence_counitIso_inv_app | Mathlib.Topology.Sheaves.Over | ∀ {X : Type u} [inst : TopologicalSpace X] (U : TopologicalSpace.Opens X) (X_1 : TopologicalSpace.Opens ↥U),
U.overEquivalence.counitIso.inv.app X_1 = CategoryTheory.eqToHom ⋯ | null | true |
Lean.Lsp.instFromJsonWorkDoneProgressOptions.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.WorkDoneProgressOptions | null | true |
Std.TreeMap.Equiv.getEntryLTD_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : α × β}, t₁.Equiv t₂ → t₁.getEntryLTD k fallback = t₂.getEntryLTD k fallback | null | true |
SubarrayIterator.step._proof_4 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u_1} (xs : Subarray α), xs.start < xs.stop → xs.start + 1 ≤ xs.stop | null | false |
Lean.PrettyPrinter.Delaborator.delabSigma | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | null | true |
WithZero.unzeroD_coe | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} (d x : α), WithZero.unzeroD d ↑x = x | null | true |
Lean.Elab.DecreasingBy.ref | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.DecreasingBy → Lean.Syntax | null | true |
_private.Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder.0.LocallyFiniteOrder.addMonoidHom._simp_4 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a = b - c) = (a + c = b) | null | false |
Representation.FiniteCyclicGroup.coinvariantsEquiv._proof_1 | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ {k : Type u_1} [inst : CommRing k], RingHomSurjective (RingHom.id k) | null | false |
Topology.RelCWComplex.FiniteDimensional.casesOn | Mathlib.Topology.CWComplex.Classical.Finite | {X : Type u} →
[inst : TopologicalSpace X] →
{C D : Set X} →
[inst_1 : Topology.RelCWComplex C D] →
{motive : Topology.RelCWComplex.FiniteDimensional C → Sort u_1} →
(t : Topology.RelCWComplex.FiniteDimensional C) →
((eventually_isEmpty_cell : ∀ᶠ (n : ℕ) in Filter.atTop, IsEmpt... | null | false |
Lean.Lsp.LeanLocationLink.mk.noConfusion | Lean.Data.Lsp.Internal | {P : Sort u} →
{toLocationLink : Lean.Lsp.LocationLink} →
{ident? : Option Lean.Lsp.LeanDeclIdent} →
{isDefault : Bool} →
{toLocationLink' : Lean.Lsp.LocationLink} →
{ident?' : Option Lean.Lsp.LeanDeclIdent} →
{isDefault' : Bool} →
{ toLocationLink := toLocationLi... | null | false |
DirichletCharacter.completedLFunction | Mathlib.NumberTheory.LSeries.DirichletContinuation | {N : ℕ} → [NeZero N] → DirichletCharacter ℂ N → ℂ → ℂ | The completed L-function of a Dirichlet character, almost everywhere equal to
`LFunction χ s * gammaFactor χ s`.
| true |
compactlySupported_eq_top_iff | Mathlib.Topology.ContinuousMap.BoundedCompactlySupported | ∀ {α : Type u_1} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalNormedRing γ] [Nontrivial γ],
compactlySupported α γ = ⊤ ↔ IsCompact Set.univ | null | true |
NumberField.InfinitePlace.Completion.coe_one | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] (v : NumberField.InfinitePlace K),
NumberField.InfinitePlace.Completion.ofCompletion ↑(WithAbs.toAbs (↑v) 1) = 1 | null | true |
Std.TreeSet.get!_emptyc | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {a : α} [inst : Inhabited α], ∅.get! a = default | null | true |
Std.IterM.all_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : MonadLiftT m n] [inst_3 : Std.IteratorLoop α m m] [inst_4 : Monad m]
[LawfulMonad m] [inst_6 : Monad n] [inst_7 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[LawfulMo... | null | true |
GroupTopology.toTopologicalSpace_injective | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u} [inst : Group α], Function.Injective GroupTopology.toTopologicalSpace | null | true |
Ordinal.toZFSet_strictMono | Mathlib.SetTheory.ZFC.Ordinal | StrictMono Ordinal.toZFSet | null | true |
RootPairing.GeckConstruction.linearIndependent_h | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {ι : 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}
[inst_5 : P.IsCrystallographic] (b : P.Base) [Finite ι] [CharZero R] [IsDomain R] [P.IsRootSystem],
LinearInde... | null | true |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.toMonoType.visitApp._sparseCasesOn_6 | Lean.Compiler.LCNF.MonoTypes | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.WalkingParallelPairHom.comp | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {X Y Z : CategoryTheory.Limits.WalkingParallelPair} →
CategoryTheory.Limits.WalkingParallelPairHom X Y →
CategoryTheory.Limits.WalkingParallelPairHom Y Z → CategoryTheory.Limits.WalkingParallelPairHom X Z | Composition of morphisms in the indexing diagram for (co)equalizers. | true |
ZMod.χ₄._proof_1 | Mathlib.NumberTheory.LegendreSymbol.ZModChar | (match 1 with
| 0 => 0
| 2 => 0
| 1 => 1
| 3 => -1) =
match 1 with
| 0 => 0
| 2 => 0
| 1 => 1
| 3 => -1 | null | false |
_private.Mathlib.Data.Set.PowersetCard.0.Set.powersetCard.ofFinEmb_surjective.match_1_1 | Mathlib.Data.Set.PowersetCard | ∀ (n : ℕ) (β : Type u_1) (motive : ↑(Set.powersetCard β n) → Prop) (h : ↑(Set.powersetCard β n)),
(∀ (s : Finset β) (hs : s ∈ Set.powersetCard β n), motive ⟨s, hs⟩) → motive h | null | false |
Lean.Grind.Config.hom._default | Init.Grind.Config | Bool | null | false |
_private.Mathlib.Tactic.Attr.Register.0.initFn._@.Mathlib.Tactic.Attr.Register.1503578496._hygCtx._hyg.5 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.SimpExtension | null | false |
Lean.Elab.Term.Context.saveRecAppSyntax._default | Lean.Elab.Term.TermElabM | Bool | null | false |
Function.fromTypes_cons_equiv_symm_apply | Mathlib.Logic.Function.FromTypes | ∀ {n : ℕ} (α : Type u) (p : Fin n → Type u) (τ : Type u) (a : Function.FromTypes (Matrix.vecCons α p) τ),
(Function.fromTypes_cons_equiv α p τ).symm a = a | null | true |
GenLoop.toLoop.eq_1 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N)
(p : ↑(GenLoop N X x)),
GenLoop.toLoop i p =
{ toFun := fun t => ⟨((↑p).comp ↑(Cube.insertAt i)).curry t, ⋯⟩, continuous_toFun := ⋯, source' := ⋯, target' := ⋯ } | null | true |
Nat.dfoldRev_succ | Init.Data.Nat.Fold | ∀ {n : ℕ} {α : (i : ℕ) → autoParam (i ≤ n + 1) Nat.dfoldRev_succ._auto_3 → Type u}
(f : (i : ℕ) → (h : i < n + 1) → α (i + 1) ⋯ → α i ⋯) (init : α (n + 1) ⋯),
(n + 1).dfoldRev f init = n.dfoldRev (fun i h => f i ⋯) (f n ⋯ init) | null | true |
Std.Iterators.HetT.pmap._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} (x : Std.Iterators.HetT m α) (f : (a : α) → x.Property a → β)
(a : Std.Internal.USquash (Subtype x.Property)), ∃ (h : x.Property ↑a.inflate), f (↑a.inflate) h = f ↑a.inflate ⋯ | null | false |
Std.IterM.Equiv.filterMapM | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α₁ α₂ β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Monad m] [inst_1 : LawfulMonad m]
[inst_2 : Monad n] [inst_3 : MonadAttach n] [inst_4 : LawfulMonad n] [inst_5 : Std.Iterator α₁ m β]
[inst_6 : Std.Iterator α₂ m β] [inst_7 : MonadLiftT m n] [LawfulMonadLiftT m n] {f : β → n (Option γ)}
... | null | true |
Int8.le_rfl | Init.Data.SInt.Lemmas | ∀ {a : Int8}, a ≤ a | null | true |
MvQPF | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} → (TypeVec.{u} n → Type u_1) → Type (max (u + 1) u_1) | Multivariate quotients of polynomial functors.
| true |
cfcₙ_comp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
Multiset.naturality | Mathlib.Data.Multiset.Functor | ∀ {G H : Type u_1 → Type u_1} [inst : Applicative G] [inst_1 : Applicative H] [inst_2 : CommApplicative G]
[inst_3 : CommApplicative H] (eta : ApplicativeTransformation G H) {α β : Type u_1} (f : α → G β) (x : Multiset α),
(fun {α} => eta.app α) (Multiset.traverse f x) = Multiset.traverse ((fun {α} => eta.app α) ∘ ... | null | true |
_private.Std.Time.Date.Unit.Week.0.Std.Time.Week.Offset.ofMinutes._proof_1 | Std.Time.Date.Unit.Week | 60 * ↑10080 = 86400 * 7 | null | false |
RandT | Mathlib.Control.Random | (Type u_1 → Type u_2) → Type u_1 → Type (max u_1 u_2) | A monad transformer to generate random objects using the generator type `StdGen`.
`RandT m α` should be thought of a random value in `m α`. | true |
CategoryTheory.Limits.Cone.fromCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
CategoryTheory.Functor (CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F)
(CategoryTheory.Limits.C... | Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
equivalence, see `Cone.equivCostructuredArrow`. | true |
hasProd_subtype_mulSupport | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α},
HasProd (f ∘ Subtype.val) a ↔ HasProd f a | null | true |
CategoryTheory.MonoidalCategory.tensorUnitRight | Mathlib.CategoryTheory.Monoidal.Category | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.MonoidalCategory C] → CategoryTheory.Functor C C | The functor `fun X ↦ X ⊗ 𝟙_ C`. | true |
Real.instRCLike._proof_10 | Mathlib.Analysis.RCLike.Basic | ∀ (x : ℝ), 0 x * 0 0 = 0 x | null | false |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq.match_4 | Lean.Meta.Sym.AlphaShareCommon | (motive : Lean.Expr → Sort u_1) →
(e₂ : Lean.Expr) →
((declName : Lean.Name) →
(type v₂ b₂ : Lean.Expr) → (nondep₂ : Bool) → motive (Lean.Expr.letE declName type v₂ b₂ nondep₂)) →
((x : Lean.Expr) → motive x) → motive e₂ | null | false |
Bool.true_bne | Init.Data.Bool | ∀ (b : Bool), (true != b) = !b | null | true |
CategoryTheory.Limits.Fan.ext._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {f : β → C}
{c₁ c₂ : CategoryTheory.Limits.Fan f} (e : c₁.pt ≅ c₂.pt),
(∀ (b : β), c₁.proj b = CategoryTheory.CategoryStruct.comp e.hom (c₂.proj b)) →
∀ (x : CategoryTheory.Discrete β), c₁.π.app x = CategoryTheory.CategoryStruct.comp ... | null | false |
Std.HashSet.get! | Std.Data.HashSet.Basic | {α : Type u} → [inst : BEq α] → [inst_1 : Hashable α] → [Inhabited α] → Std.HashSet α → α → α | Checks if given key is contained and returns the key if it is, otherwise panics.
If no panic occurs the result is guaranteed to be pointer equal to the key in the set.
| true |
Polynomial.quo_add_sum_rem_div_unique | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra (Polynomial R) K]
[FaithfulSMul (Polynomial R) K] {ι : Type u_3} {g : ι → Polynomial R} {s : Finset ι},
(∀ i ∈ s, (g i).Monic) →
((↑s).Pairwise fun i j => IsCoprime (g i) (g j)) →
∀ {q₁ q₂ : Polynomial R} {r₁ r₂ : ι →... | Let `R` be an integral domain and `f : R[X]`. Let `s` be a finite index set.
Then a fraction of the form `f / ∏ i ∈ s, g i` evaluated in a field `K` containing `R[X]`
can be rewritten as `q + ∑ i ∈ s, r i / g i` in at most one way, where
`degree (r i) < degree (g i)`, provided that the `g i` are monic and pairwise copr... | true |
MvPolynomial.ne_zero_of_degreeOf_ne_zero | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {i : σ},
MvPolynomial.degreeOf i p ≠ 0 → p ≠ 0 | null | true |
FractionalIdeal.one_le_dual_one | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (K : Type u_2) {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | true |
OrderDual.ofDual_trans_toDual | Mathlib.Order.OrderDual | ∀ {α : Type u_1}, OrderDual.ofDual.trans OrderDual.toDual = Equiv.refl αᵒᵈ | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable.0.E2_mdifferentiable._simp_1_7 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.MDifferentiable | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk.injEq | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | ∀ (module const : Lean.Name) (exception : Lean.Exception) (module_1 const_1 : Lean.Name) (exception_1 : Lean.Exception),
({ module := module, const := const, exception := exception } =
{ module := module_1, const := const_1, exception := exception_1 }) =
(module = module_1 ∧ const = const_1 ∧ exception = ex... | null | true |
Mathlib.Tactic.FieldSimp.Sign.congr | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
{y y' : Q(«$M»)} →
(g : Mathlib.Tactic.FieldSimp.Sign M) →
Q(«$y» = «$y'») →
have a := g.expr y';
have a_1 := g.expr y;
Q(«$a_1» = «$a») | Given a proof that two expressions `y₁ y₂ : Q($M)` are equal, construct a proof that (± `y₁`)
and (± `y₂`) are equal, where the same sign is taken in both expression. | true |
ENat.top_ne_one._simp_1 | Mathlib.Data.ENat.Basic | (⊤ = 1) = False | null | false |
ContinuousAffineMap.zero_apply | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] (x : P), 0 x = 0 | null | true |
Lean.Meta.Grind.Arith.Linear.State.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive : Lean.Meta.Grind.Arith.Linear.State → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.State) →
((structs : Array Lean.Meta.Grind.Arith.Linear.Struct) →
(typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)) →
(exprToStructId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) →
(exprT... | null | false |
MeasureTheory.innerRegularWRT_isCompact_isClosed_measure_ne_top_of_group | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G] [h : μ.InnerRegularCompactLTTop],
μ.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) fun s => MeasurableSet s ∧ μ s ≠ ⊤ | null | true |
Aesop.RuleState.mk.inj | Aesop.Forward.State | ∀ {rule : Aesop.ForwardRule} {clusterStates : Array Aesop.ClusterState}
{patSubstSources : Lean.PHashMap Aesop.Substitution (Lean.PHashSet Aesop.PatSubstSource)} {rule_1 : Aesop.ForwardRule}
{clusterStates_1 : Array Aesop.ClusterState}
{patSubstSources_1 : Lean.PHashMap Aesop.Substitution (Lean.PHashSet Aesop.Pat... | null | true |
Subring.sum_mem | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] (s : Subring R) {ι : Type u_2} {t : Finset ι} {f : ι → R},
(∀ c ∈ t, f c ∈ s) → ∑ i ∈ t, f i ∈ s | Sum of elements in a `Subring` of a `Ring` indexed by a `Finset`
is in the `Subring`. | true |
Ideal.ramificationIdx_smul | Mathlib.RingTheory.RamificationInertia.Ramification | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (q : Ideal S)
{G : Type u_4} [inst_3 : Group G] [inst_4 : MulSemiringAction G S] [SMulCommClass G R S] (g : G),
(g • q).ramificationIdx R = q.ramificationIdx R | null | true |
Lean.Meta.simpEq | Mathlib.Lean.Meta.Simp | (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | Independently simplify both the left-hand side and the right-hand side
of an equality. The equality is allowed to be under binders.
Returns the simplified equality and a proof of it. | true |
RingQuot.instRing._proof_4 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Ring R] (r : R → R → Prop) (n : ℕ) (a : RingQuot r), Int.negSucc n • a = -(↑n.succ • a) | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.RealizeConstantResult.mk.inj | Lean.Meta.Basic | ∀ {snap? : Option Lean.Language.SnapshotTree} {error? : Option Lean.Exception}
{snap?_1 : Option Lean.Language.SnapshotTree} {error?_1 : Option Lean.Exception},
{ snap? := snap?, error? := error? } = { snap? := snap?_1, error? := error?_1 } → snap? = snap?_1 ∧ error? = error?_1 | null | true |
Valued.toNormedField._proof_3 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ (L : Type u_1) [inst : Field L] (Γ₀ : Type u_2) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [val : Valued L Γ₀]
[hv : Valued.v.RankOne] (x y : L), Valued.v.norm (x - y) = Valued.v.norm (y - x) | null | false |
_private.Mathlib.Data.PFun.0.PFun.mem_prodMap._simp_1_5 | Mathlib.Data.PFun | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
CategoryTheory.Limits.Types.Small.productLimitCone._proof_4 | Mathlib.CategoryTheory.Limits.Types.Products | ∀ {J : Type u_1} (F : J → Type u_2) [inst : Small.{u_2, u_1} J]
(s : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor F))
(m :
s.pt ⟶
{ pt := Shrink.{u_2, max u_2 u_1} ((j : J) → F j),
π :=
CategoryTheory.Discrete.natTrans fun x =>
match x with
... | null | false |
Homeomorph.prodUnique_symm_apply_snd | Mathlib.Topology.Homeomorph.Lemmas | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : Unique Y] (a : X),
((Homeomorph.prodUnique X Y).symm a).2 = default | null | true |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.coeff_zero_of_lt_valuation._proof_1_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K] {n D : ℤ} {f : LaurentSeries K},
n < D → HahnSeries.order f ≤ n → ∀ (s : ℕ), HahnSeries.order f = -↑s → 0 ≤ D + ↑s | null | false |
AddSubmonoid.giMapComap.match_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_3} [inst : FunLike F M N] {f : F} (x : N) (motive : (∃ a, f a = x) → Prop)
(x_1 : ∃ a, f a = x), (∀ (y : M) (hy : f y = x), motive ⋯) → motive x_1 | null | false |
Lean.Meta.Grind.Solvers.mkInitialStates | Lean.Meta.Tactic.Grind.Types | IO (Array Lean.Meta.Grind.SolverExtensionState) | Returns initial state for registered solvers. | true |
SSet.Truncated.Edge.mk'._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | ∀ {X : SSet.Truncated 2} (s : X.obj (Opposite.op { obj := { len := 1 }, property := SSet.Truncated.Edge._proof_2 })),
(CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op))
s =
(CategoryTheory.ConcreteCategory.hom
... | null | false |
mdifferentiable_neg_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_12 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {a c : M} {b d : ↥S},
(Localization.mk a b = Localization.mk c d) = (Localization.r S) (a, b) (c, d) | null | false |
_private.Mathlib.Tactic.Basify.0.Mathlib.Tactic.Basify.basifyLoop.match_1 | Mathlib.Tactic.Basify | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((decl : Lean.LocalDecl) → motive (some decl)) → ((x : Option Lean.LocalDecl) → motive x) → motive x | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.isLindelof_of_countable_subcover._simp_1_2 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, (a ⊓ b = ⊥) = Disjoint a b | null | false |
CategoryTheory.ShortComplex.π_isoOpcyclesOfIsColimit_hom_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology] {cc : CategoryTheory.Limits.CokernelCofork S.f}
(hcc : CategoryTheory.Limits.IsColimit cc) {Z : C} (h : S.opcycles ⟶ Z),
CategoryTheo... | null | true |
RingHom.op_symm_apply_apply | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_3} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : Rᵐᵒᵖ →+* Sᵐᵒᵖ) (a : R),
(RingHom.op.symm f) a = MulOpposite.unop (f (MulOpposite.op a)) | null | true |
IsOrderedVAdd.mk._flat_ctor | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} [inst : LE G] [inst_1 : LE P] [inst_2 : VAdd G P],
(∀ (a b : P), a ≤ b → ∀ (c : G), c +ᵥ a ≤ c +ᵥ b) →
(∀ (c d : G), c ≤ d → ∀ (a : P), c +ᵥ a ≤ d +ᵥ a) → IsOrderedVAdd G P | null | false |
_private.Mathlib.Order.Interval.Finset.Gaps.0.Finset.intervalGapsWithin_snd_of_lt._proof_1_1 | Mathlib.Order.Interval.Finset.Gaps | ∀ {k : ℕ}, ∀ j < k, ¬↑j = Fin.last k | null | false |
mem_nhdsWithin_iff_eventuallyEq | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α} {x : α}, t ∈ nhdsWithin x s ↔ s =ᶠ[nhds x] s ∩ t | **Alias** of `mem_nhdsWithin_iff_eventuallyEqSet`. | true |
Lean.Meta.Occurrences.recOn | Init.MetaTypes | {motive : Lean.Meta.Occurrences → Sort u} →
(t : Lean.Meta.Occurrences) →
motive Lean.Meta.Occurrences.all →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.pos idxs)) →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.neg idxs)) → motive t | null | false |
TopCat.Presheaf.SubmonoidPresheaf.mk | Mathlib.Topology.Sheaves.CommRingCat | {X : TopCat} →
{F : TopCat.Presheaf CommRingCat X} →
(obj : (U : (TopologicalSpace.Opens ↑X)ᵒᵖ) → Submonoid ↑(F.obj U)) →
(∀ {U V : (TopologicalSpace.Opens ↑X)ᵒᵖ} (i : U ⟶ V),
obj U ≤ Submonoid.comap (CommRingCat.Hom.hom (F.map i)) (obj V)) →
F.SubmonoidPresheaf | null | true |
Mathlib.Tactic.ClickSuggestions.GrwLemma.symm | Mathlib.Tactic.ClickSuggestions.GRewrite | Mathlib.Tactic.ClickSuggestions.GrwLemma → Bool | `symm` is `true` when rewriting from right to left | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.instInhabitedStained | Mathlib.Tactic.Linter.FlexibleLinter | Inhabited Mathlib.Linter.Flexible.Stained✝ | null | true |
Submodule.FG.generators_mem | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
p.generators ⊆ ↑p | The elements of the generators are in the submodule. | true |
Ring.krullDimLE_of_isLocalization_maximal | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (Rₚ : (P : Ideal R) → [P.IsMaximal] → Type u_2)
[inst_1 : (P : Ideal R) → [inst : P.IsMaximal] → CommRing (Rₚ P)]
[inst_2 : (P : Ideal R) → [inst_2 : P.IsMaximal] → Algebra R (Rₚ P)]
[∀ (P : Ideal R) [inst_3 : P.IsMaximal], IsLocalization.AtPrime (Rₚ P) P] {n : ℕ},
(∀ (P : I... | null | true |
IsChain.preimage_embedding | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {t : Set β},
IsChain (fun x1 x2 => x1 ≤ x2) t → ∀ (φ : α ↪o β), IsChain (fun x1 x2 => x1 ≤ x2) (⇑φ ⁻¹' t) | null | true |
Lean.PrettyPrinter.Parenthesizer.checkStackTop.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.Bicategory.Prod.fst_obj | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] (a : B × C),
(CategoryTheory.Bicategory.Prod.fst B C).obj a = a.1 | null | true |
Nat.Subtype.semilatticeSup._proof_2 | Mathlib.Data.Nat.Order.Lemmas | ∀ (p : ℕ → Prop) (a b : Subtype p), b ≤ SemilatticeSup.sup a b | null | false |
_private.Mathlib.Algebra.Order.ToIntervalMod.0.AddCommGroup.modEq_iff_toIcoMod_add_period_eq_toIocMod._proof_1_2 | Mathlib.Algebra.Order.ToIntervalMod | 4 ≠ 0 | null | false |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Balanced → (n : ℕ) → n < t.size → α × β | null | false |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.Gamma_mem._simp_1_3 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Ordinal.isSuccPrelimit_type_lt_iff | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} [inst : LinearOrder α] [inst_1 : WellFoundedLT α],
Order.IsSuccPrelimit (Ordinal.type fun x1 x2 => x1 < x2) ↔ NoMaxOrder α | null | true |
CategoryTheory.MonoidalCategory.tensorLeftTensor._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z Z' : C} (f : Z ⟶ Z'),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensorLeft (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).map f)
(CategoryTheory.Mon... | null | false |
_private.Init.Prelude.0.Lean.extractMacroScopesAux._unsafe_rec | Init.Prelude | Lean.Name → List Lean.MacroScope → Lean.MacroScopesView | null | false |
_private.Init.Data.Nat.Internal.Linear.0.Nat.Internal.Linear.Poly.cancelAux.match_1.eq_2 | Init.Data.Nat.Internal.Linear | ∀ (motive : Nat.Internal.Linear.Poly → Nat.Internal.Linear.Poly → Sort u_1) (m₂ : Nat.Internal.Linear.Poly)
(h_1 : (m₁ : Nat.Internal.Linear.Poly) → motive m₁ []) (h_2 : (m₂ : Nat.Internal.Linear.Poly) → motive [] m₂)
(h_3 :
(k₁ : ℕ) →
(v₁ : Nat.Internal.Linear.Var) →
(m₁ : List (ℕ × Nat.Internal.... | null | true |
SimpleGraph.IsEdgeConnected.le_degree | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ∞} {u : V} [inst : Fintype ↑(G.neighborSet u)] [Nontrivial V],
G.IsEdgeConnected k → k ≤ ↑(G.degree u) | null | true |
Std.Iter.Total.mk | Init.Data.Iterators.Consumers.Total | {α β : Type w} → Std.Iter β → Std.Iter.Total β | null | true |
Lean.Compiler.LCNF.UnreachableBranches.Value._sizeOf_1 | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.UnreachableBranches.Value → ℕ | null | false |
Lean.Expr.CollectLooseBVars.main | Lean.Util.CollectLooseBVars | Lean.Expr → ℕ → Lean.Expr.CollectLooseBVars.M Unit | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.