name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Do.Spec.forIn'_list._proof_5 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : List α}, xs ++ [] = xs |
Std.TreeMap.Raw.minKeyD_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β} {fallback : α},
(t.insert k v).minKeyD fallback = t.minKey?.elim k fun k' => if (cmp k k').isLE = true then k else k' |
hasFDerivWithinAt_pi' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{Φ' : E →L[𝕜] (i : ι) → F' i},
HasFDerivWithinAt Φ Φ' s x ↔ ∀ (i : ι), HasFDerivWithinAt (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') s x |
Functor.map_unit | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} [inst : Functor f] [LawfulFunctor f] {a : f PUnit.{u_1 + 1}},
(fun x => PUnit.unit) <$> a = a |
Sym.filterNe._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (m : Sym α n), (↑m).card < n + 1 |
Lean.IR.Expr.proj.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 3 → ((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) → motive t |
SkewMonoidAlgebra.noConfusion | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {P : Sort u} →
{k : Type u_1} →
{G : Type u_2} →
{inst : Zero k} →
{t : SkewMonoidAlgebra k G} →
{k' : Type u_1} →
{G' : Type u_2} →
{inst' : Zero k'} →
{t' : SkewMonoidAlgebra k' G'} →
k = k' → G = G' → inst ≍ inst' → t ≍ t' → SkewMonoidAlgebra.noConfusionType P t t' |
Vector.getElem?_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m i : ℕ} {xs : Vector α n} {ys : Vector α m}, n ≤ i → (xs ++ ys)[i]? = ys[i - n]? |
Lean.Level.collectMVars | Lean.Level | Lean.Level → optParam Lean.LMVarIdSet ∅ → Lean.LMVarIdSet |
NormedAddTorsor | Mathlib.Analysis.Normed.Group.AddTorsor | (V : outParam (Type u_1)) → (P : Type u_2) → [SeminormedAddCommGroup V] → [PseudoMetricSpace P] → Type (max u_1 u_2) |
SubMulAction.instSMulSubtypeMem._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M] (p : SubMulAction R M) (c : R) (x : ↥p), c • ↑x ∈ p |
ωCPO._sizeOf_1 | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ |
IsAlgebraic.smul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {A : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → ∀ (r : R), IsAlgebraic R (r • a) |
Quiver.Path.nil | Mathlib.Combinatorics.Quiver.Path | {V : Type u} → [inst : Quiver V] → {a : V} → Quiver.Path a a |
_private.Init.Data.List.Impl.0.List.zipWith_eq_zipWithTR.go | Init.Data.List.Impl | ∀ (α : Type u_3) (β : Type u_2) (γ : Type u_1) (f : α → β → γ) (as : List α) (bs : List β) (acc : Array γ),
List.zipWithTR.go✝ f as bs acc = acc.toList ++ List.zipWith f as bs |
WeierstrassCurve.Projective.Point.mk.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Projective R}
{point : WeierstrassCurve.Projective.PointClass R} {nonsingular : W'.NonsingularLift point}
{point_1 : WeierstrassCurve.Projective.PointClass R} {nonsingular_1 : W'.NonsingularLift point_1},
{ point := point, nonsingular := nonsingular } = { point := point_1, nonsingular := nonsingular_1 } → point = point_1 |
LinearMap.IsIdempotentElem.isSymmetric_iff_isOrtho_range_ker | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E}, IsIdempotentElem T → (T.IsSymmetric ↔ T.range ⟂ T.ker) |
dist_le_range_sum_dist | Mathlib.Topology.MetricSpace.Pseudo.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (f : ℕ → α) (n : ℕ),
dist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, dist (f i) (f (i + 1)) |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheorems |
CStarMatrix.ofMatrixRingEquiv._proof_2 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Semiring A] (x x_1 : Matrix n n A),
CStarMatrix.ofMatrix.toFun (x + x_1) = CStarMatrix.ofMatrix.toFun (x + x_1) |
PiTensorProduct.mapMultilinear_apply | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_4) [inst : CommSemiring R] (s : ι → Type u_7) [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (t : ι → Type u_11) [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i →ₗ[R] t i),
(PiTensorProduct.mapMultilinear R s t) f = PiTensorProduct.map f |
«term_=_» | Init.Notation | Lean.TrailingParserDescr |
CategoryTheory.Over.prodLeftIsoPullback_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.Limits.HasPullback Y.hom Z.hom] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
{Z_1 : C} (h : Y.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (Y.prodLeftIsoPullback Z).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst Y.hom Z.hom) h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.fst.left h |
_private.Init.Data.List.Perm.0.List.reverse_perm.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive x |
Matrix.det_of_mem_unitary | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
{A : Matrix n n α}, A ∈ Matrix.unitaryGroup n α → A.det ∈ unitary α |
instAB4AddCommGrpCat | Mathlib.Algebra.Category.Grp.AB | CategoryTheory.AB4 AddCommGrpCat |
ContinuousAt.lineMap | Mathlib.Topology.Algebra.Affine | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : AddCommGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : Ring R]
[inst_6 : Module R V] [inst_7 : TopologicalSpace R] [ContinuousSMul R V] {X : Type u_6} [inst_9 : TopologicalSpace X]
{f₁ f₂ : X → P} {g : X → R} {x : X},
ContinuousAt f₁ x →
ContinuousAt f₂ x → ContinuousAt g x → ContinuousAt (fun x => (AffineMap.lineMap (f₁ x) (f₂ x)) (g x)) x |
AddMonoidAlgebra.le_infDegree_mul | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
[inst_3 : AddZeroClass A] [inst_4 : Add T] [AddLeftMono T] [AddRightMono T] (D : A →ₙ+ T)
(f g : AddMonoidAlgebra R A),
AddMonoidAlgebra.infDegree (⇑D) f + AddMonoidAlgebra.infDegree (⇑D) g ≤ AddMonoidAlgebra.infDegree (⇑D) (f * g) |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.1964439861._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_5 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a ≤ x ∧ x ≤ b → ¬((x - a).toNat < (b + 1 - a).toNat ∧ a + ↑(x - a).toNat = x) → False |
instCompleteLatticeStructureGroupoid._proof_7 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), b ≤ SemilatticeSup.sup a b |
_private.Mathlib.RingTheory.Nilpotent.Exp.0.IsNilpotent.exp_add_of_commute._proof_1_3 | Mathlib.RingTheory.Nilpotent.Exp | ∀ (n₁ n₂ : ℕ), max n₁ n₂ + 1 + (max n₁ n₂ + 1) ≤ 2 * max n₁ n₂ + 1 + 1 |
_private.Lean.Meta.Tactic.ExposeNames.0.Lean.Meta.getLCtxWithExposedNames | Lean.Meta.Tactic.ExposeNames | Lean.MetaM Lean.LocalContext |
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 |
Empty.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | BorelSpace Empty |
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 |
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 w_1 n : ℕ) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size ≤ { aig := aig_1, vec := expr }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate (↑⟨{ aig := aig_1, vec := expr }, haig⟩).aig
{ w := w_1, n := n, inner := expr, h := h }).aig.decls.size |
Std.Time.Month.Ordinal.january | Std.Time.Date.Unit.Month | Std.Time.Month.Ordinal |
Aesop.RuleResult.ctorIdx | Aesop.Search.Expansion | Aesop.RuleResult → ℕ |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {w : ℕ}, ∀ curr < w, curr + 1 ≤ w |
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.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) S₁.g = 0)
(hi :
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv φ.τ₂)) wi)),
hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯) = CategoryTheory.CategoryStruct.comp φ.τ₁ h.f' →
∀ {Z' : C} (x : h.K ⟶ Z'),
CategoryTheory.CategoryStruct.comp (hi.lift (CategoryTheory.Limits.KernelFork.ofι S₁.f ⋯)) x = 0 →
CategoryTheory.CategoryStruct.comp h.f' x = 0 |
Subsemiring.instTop._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R], 0 ∈ ⊤.carrier |
_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 |
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 : Module R M₁]
[inst_7 : AddCommGroup N₁] [inst_8 : Module R N₁] [inst_9 : AddCommGroup M₂] [inst_10 : Module R M₂]
[inst_11 : AddCommGroup N₂] [inst_12 : Module R N₂] {P : RootPairing ι R M N} {P₁ : RootPairing ι₁ R M₁ N₁}
{P₂ : RootPairing ι₂ R M₂ N₂} (g : P₁.Hom P₂) (f : P.Hom P₁),
⇑(f.coweightMap ∘ₗ g.coweightMap) ∘ ⇑P₂.coroot = ⇑P.coroot ∘ ⇑(f.indexEquiv.trans g.indexEquiv).symm |
SchwartzMap.compCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (k n l : ℕ) (C : ℝ),
0 ≤ C →
∀ (kg : ℕ) (Cg : ℝ), 1 ≤ 1 + Cg → 0 ≤ (1 + Cg) ^ (k + l * n) * ((C + 1) ^ n * ↑n.factorial * 2 ^ (kg * (k + l * n))) |
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 |
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 |
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} |
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 : TopologicalSpace M₂] [inst_8 : ContinuousSMul R M₂] (f : ContinuousMultilinearMap R M₁ R) (z : M₂)
(a : (i : ι) → M₁ i), (f.smulRight z) a = f a • z |
Int.negOnePow_two_mul_add_one | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), (2 * n + 1).negOnePow = -1 |
Lean.Server.Watchdog.CallHierarchyItemData | Lean.Server.Watchdog | Type |
Std.Time.FormatPart.noConfusionType | Std.Time.Format.Basic | Sort u → Std.Time.FormatPart → Std.Time.FormatPart → Sort u |
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⟩ |
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| |
isOpenMap_sigmaMk | Mathlib.Topology.Constructions | ∀ {ι : Type u_5} {σ : ι → Type u_7} [inst : (i : ι) → TopologicalSpace (σ i)] {i : ι}, IsOpenMap (Sigma.mk i) |
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 |
Int64.right_eq_add | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, b = a + b ↔ a = 0 |
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₂ |
_private.Mathlib.Computability.TuringMachine.0.Turing.TM2.stepAux.match_1.splitter | Mathlib.Computability.TuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
(motive : Turing.TM2.Stmt Γ Λ σ → σ → ((k : K) → List (Γ k)) → Sort u_5) →
(x : Turing.TM2.Stmt Γ Λ σ) →
(x_1 : σ) →
(x_2 : (k : K) → List (Γ k)) →
((k : K) →
(f : σ → Γ k) →
(q : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.push k f q) v S) →
((k : K) →
(f : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.peek k f q) v S) →
((k : K) →
(f : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.pop k f q) v S) →
((a : σ → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.load a q) v S) →
((f : σ → Bool) →
(q₁ q₂ : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.branch f q₁ q₂) v S) →
((f : σ → Λ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.goto f) v S) →
((v : σ) → (S : (k : K) → List (Γ k)) → motive Turing.TM2.Stmt.halt v S) → motive x x_1 x_2 |
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 |
CompletelyDistribLattice.top_sdiff | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [self : CompletelyDistribLattice α] (a : α), ⊤ \ a = ￢a |
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 |
Lean.Widget.GetInteractiveDiagnosticsParams.mk.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (lineRange? : Option Lean.Lsp.LineRange), sizeOf { lineRange? := lineRange? } = 1 + sizeOf lineRange? |
Std.Net.SocketAddress | Std.Net.Addr | Type |
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 |
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))
(w :
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
{Z_1 : C} (h : Q.complex.X (n + 2) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
(CategoryTheory.CategoryStruct.comp (Q.complex.d (n + 3) (n + 2)) h) =
CategoryTheory.CategoryStruct.comp
(f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g') h |
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)
(j : J) (ι : i₀ ⟶ j), CategoryTheory.IsIso (c.ι.app j) |
_private.Lean.Syntax.0.Lean.Syntax.findStack?.go.match_3 | Lean.Syntax | (motive : Option (Option Lean.Syntax.Stack) → Sort u_1) →
(x : Option (Option Lean.Syntax.Stack)) →
(Unit → motive none) → ((a : Option Lean.Syntax.Stack) → motive (some a)) → motive x |
PUnit.inv_eq | Mathlib.Algebra.Group.PUnit | ∀ (x : PUnit.{u_1 + 1}), x⁻¹ = PUnit.unit |
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, u_5} C] (G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C))
{K₁ : CategoryTheory.Functor J₁ C₁} {K₂ : CategoryTheory.Functor J₂ C₂} (c₁ : CategoryTheory.Limits.Cocone K₁)
(c₂ : CategoryTheory.Limits.Cocone K₂), (G.mapCocone₂ c₁ c₂).pt = (G.obj c₁.pt).obj c₂.pt |
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 |
MontelSpace.rec | Mathlib.Analysis.LocallyConvex.Montel | {𝕜 : Type u_4} →
{E : Type u_5} →
[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) → motive ⋯) →
(t : MontelSpace 𝕜 E) → motive t |
Subgroup.pi | Mathlib.Algebra.Group.Subgroup.Basic | {η : Type u_7} →
{f : η → Type u_8} → [inst : (i : η) → Group (f i)] → Set η → ((i : η) → Subgroup (f i)) → Subgroup ((i : η) → f i) |
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 |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg | Lean.Elab.App | Lean.Name → Lean.Elab.Term.ElabAppArgs.M Lean.Expr |
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₂ |
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 |
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) |
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) |
SimpleGraph.Subgraph._sizeOf_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → [SizeOf V] → G.Subgraph → ℕ |
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 |
_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 |
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) |
AddMonoidHom.range_eq_top_of_surjective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] (f : G →+ N),
Function.Surjective ⇑f → f.range = ⊤ |
Real.convergent_zero | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ (ξ : ℝ), ξ.convergent 0 = ↑⌊ξ⌋ |
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.conjugateEquiv adj₂ adj₁) α.inv |
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) |
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) |
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 |
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 |
FBinopElab.instInhabitedSRec | Mathlib.Tactic.FBinop | Inhabited FBinopElab.SRec |
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 : CategoryTheory.Functor Cᵒᵖ D} {S : J.Cover X} (x : CategoryTheory.Meq P S) {Y : C} {f g : Y ⟶ X} (h : f = g)
(hf : (↑S).arrows f), ↑x { Y := Y, f := f, hf := hf } = ↑x { Y := Y, f := g, hf := ⋯ } |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.SimpleGroundValue.uint8.sizeOf_spec | Lean.Compiler.IR.SimpleGroundExpr | ∀ (val : UInt8), sizeOf (Lean.IR.SimpleGroundValue.uint8✝ val) = 1 + sizeOf val |
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)) |
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 ⋯ |
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 |
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.Bicategory.leftZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam)
(unit_1 : CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g)
(counit_1 : CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b)
(left_triangle_1 :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle_1 :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam),
({ unit := unit, counit := counit, left_triangle := left_triangle, right_triangle := right_triangle } =
{ unit := unit_1, counit := counit_1, left_triangle := left_triangle_1, right_triangle := right_triangle_1 }) =
(unit = unit_1 ∧ counit = counit_1) |
Mathlib.Tactic.ITauto.Proof.em | Mathlib.Tactic.ITauto | Bool → Lean.Name → Mathlib.Tactic.ITauto.Proof |
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 |
Lean.NameMapExtension.find? | Batteries.Lean.NameMapAttribute | {α : Type} → Lean.NameMapExtension α → Lean.Environment → Lean.Name → Option α |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.