name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Bool.instDecidableLe | Init.Data.Bool | (x y : Bool) → Decidable (x ≤ y) |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache._sizeOf_1 | Std.Sat.AIG.CNF | {aig : Std.Sat.AIG ℕ} → {cnf : Std.Sat.CNF ℕ} → Std.Sat.AIG.toCNF.Cache✝ aig cnf → ℕ |
PredOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α),
¬Order.IsPredPrelimit a → ∃ b, ¬IsMin b ∧ Order.pred b = a |
Lean.Doc.Syntax.footnote_ref | Lean.DocString.Syntax | Lean.ParserDescr |
Batteries.Tactic.tacticSplit_ands | Batteries.Tactic.Init | Lean.ParserDescr |
_private.Batteries.Data.UnionFind.Lemmas.0.Batteries.UnionFind.equiv_union._simp_1_4 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ} {self : Batteries.UnionFind} {x : Fin self.size}, (self.find x).fst.Equiv a b = self.Equiv a b |
Lean.Meta.Grind.Goal.ppENodeRef | Lean.Meta.Tactic.Grind.PP | Lean.Meta.Grind.Goal → Lean.Expr → Lean.MetaM Lean.MessageData |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_13 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') |
_private.Mathlib.Util.PrintSorries.0.Mathlib.PrintSorries.collect._sparseCasesOn_1 | Mathlib.Util.PrintSorries | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ComposableArrows.ext | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(h : ∀ (i : Fin (n + 1)), F.obj i = G.obj i),
(∀ (i : ℕ) (hi : i < n),
F.map' i (i + 1) ⋯ hi =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (G.map' i (i + 1) ⋯ hi) (CategoryTheory.eqToHom ⋯))) →
F = G |
Subgroup.normalizer_eq_top | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [h : H.Normal], H.normalizer = ⊤ |
circleMap_zero_zpow | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (n : ℤ) (R θ : ℝ), circleMap 0 R θ ^ n = circleMap 0 (R ^ n) (↑n * θ) |
Lean.Grind.Linarith.Expr.intMul | Init.Grind.Ordered.Linarith | ℤ → Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Expr |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.casesOn | Lean.Meta.Sym.Simp.Forall | {motive : Lean.Meta.Sym.Simp.ArrowInfo✝ → Sort u} →
(t : Lean.Meta.Sym.Simp.ArrowInfo✝¹) →
((binderName : Lean.Name) →
(binderInfo : Lean.BinderInfo) →
(u v : Lean.Level) → motive { binderName := binderName, binderInfo := binderInfo, u := u, v := v }) →
motive t |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.Slice.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) |
Equiv.piUnique | Mathlib.Logic.Equiv.Defs | {α : Sort u} → [inst : Unique α] → (β : α → Sort u_1) → ((i : α) → β i) ≃ β default |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW.match_1_1 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C] (X₁ X₂ : C) (f : X₁ ⟶ X₂) (motive : P.trW f → Prop) (x : P.trW f),
(∀ (X₃ : C) (g : X₂ ⟶ X₃) (h : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁)
(hT : CategoryTheory.Pretriangulated.Triangle.mk f g h ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
(hX₃ : P X₃), motive ⋯) →
motive x |
EuclideanGeometry.Sphere._sizeOf_inst | Mathlib.Geometry.Euclidean.Sphere.Basic | (P : Type u_2) → {inst : MetricSpace P} → [SizeOf P] → SizeOf (EuclideanGeometry.Sphere P) |
Mathlib.Meta.NormNum.deriveBool | Mathlib.Tactic.NormNum.Core | (p : Q(Prop)) → Lean.MetaM ((b : Bool) × Mathlib.Meta.NormNum.BoolResult p b) |
Filter.zeroAtFilterSubmodule | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | (𝕜 : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace β] →
[inst_1 : Semiring 𝕜] →
[inst_2 : AddCommMonoid β] →
[inst_3 : Module 𝕜 β] → [ContinuousAdd β] → [ContinuousConstSMul 𝕜 β] → Filter α → Submodule 𝕜 (α → β) |
Std.DTreeMap.Const.ofList_eq_insertMany_empty | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {l : List (α × β)},
Std.DTreeMap.Const.ofList l cmp = Std.DTreeMap.Const.insertMany ∅ l |
Lean.LocalInstance.casesOn | Lean.MetavarContext | {motive : Lean.LocalInstance → Sort u} →
(t : Lean.LocalInstance) →
((className : Lean.Name) → (fvar : Lean.Expr) → motive { className := className, fvar := fvar }) → motive t |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.computedField.formatter_117 | Lean.Parser.Command | IO Unit |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.rec._proof_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (o : Ordinal.{u_1}), o = 0 → 0 = o |
Relation.reflTransGen_of_equivalence | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a b : α} {r' : α → α → Prop},
Equivalence r → (∀ (a b : α), r' a b → r a b) → Relation.ReflTransGen r' a b → r a b |
Lean.Meta.Grind.instInhabitedAction | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Action |
QuaternionAlgebra.im_imI | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} (a : QuaternionAlgebra R c₁ c₂ c₃) [inst : Zero R], a.im.imI = a.imI |
_private.Mathlib.Algebra.Polynomial.RingDivision.0.Polynomial.prime_X_sub_C._simp_1_2 | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) |
List.findSomeRev?.eq_def | Init.Data.List.Impl | ∀ {α : Type u} {β : Type v} (f : α → Option β) (x : List α),
List.findSomeRev? f x =
match x with
| [] => none
| a :: as =>
match List.findSomeRev? f as with
| some b => some b
| none => f a |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitMData | Lean.Compiler.LCNF.ToLCNF | Lean.MData → Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) |
_private.Mathlib.Logic.Embedding.Set.0.Function.Embedding.sigmaSet_preimage._simp_1_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b |
Topology.CWComplex.Subcomplex.coe_mk'' | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) [h : Topology.CWComplex C] (E : Set X)
(I : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)) [inst_1 : Topology.CWComplex E]
(union : ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = E), ↑(Topology.CWComplex.Subcomplex.mk'' C E I union) = E |
_private.Mathlib.Analysis.Convex.Combination.0.AffineIndependent.convexHull_inter._simp_1_4 | Mathlib.Analysis.Convex.Combination | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), (∑ a ∈ s, if p a then f a else 0) = ∑ a ∈ s with p a, f a |
Lean.Meta.initFn._@.Lean.Meta.Coe.1863807188._hygCtx._hyg.2 | Lean.Meta.Coe | IO Lean.TagAttribute |
Lean.StructureResolutionState.casesOn | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
(t : Lean.StructureResolutionState) →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) → motive t |
WeierstrassCurve.variableChange_j | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], (C • W).j = W.j |
Lean.Options.ctorIdx | Lean.Data.Options | Lean.Options → ℕ |
Cardinal.lift_max | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b) |
CategoryTheory.presheafHom | Mathlib.CategoryTheory.Sites.SheafHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Functor Cᵒᵖ A →
CategoryTheory.Functor Cᵒᵖ A → CategoryTheory.Functor Cᵒᵖ (Type (max (max u v) v')) |
QuaternionAlgebra.im_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), (↑n).im = 0 |
Mathlib.Tactic.FinVec.vecPerm | Mathlib.Tactic.Simproc.VecPerm | Lean.Meta.Simp.Simproc |
Matroid.IsLoop.dep_of_mem._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax |
IsValuativeTopology.instIsTopologicalRing | Mathlib.Topology.Algebra.Valued.ValuativeRel | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R],
IsTopologicalRing R |
ModularForm.eisensteinSeriesMF._proof_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ∀ {k : ℤ} {N : ℕ} (a : Fin 2 → ZMod N),
∀ γ ∈ Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N),
SlashAction.map k γ (EisensteinSeries.eisensteinSeriesSIF a k).toFun =
(EisensteinSeries.eisensteinSeriesSIF a k).toFun |
SetLike.instSubtypeSet._proof_1 | Mathlib.Data.SetLike.Basic | ∀ {X : Type u_1} {p : Set X → Prop}, Function.Injective Subtype.val |
Lean.Order.Array.monotone_allM | Init.Internal.Order.Lemmas | ∀ {γ : Type w} [inst : Lean.Order.PartialOrder γ] {m : Type → Type v} [inst_1 : Monad m]
[inst_2 : (α : Type) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m] {α : Type u} (f : γ → α → m Bool)
(xs : Array α) (start stop : ℕ), Lean.Order.monotone f → Lean.Order.monotone fun x => Array.allM (f x) xs start stop |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {V : Type u_1} →
{G : SimpleGraph V} →
{r t : ℕ} → (SimpleGraph.completeEquipartiteGraph r t).Copy G → G.CompleteEquipartiteSubgraph r t |
_private.Mathlib.Topology.Algebra.InfiniteSum.Order.0.Mathlib.Meta.Positivity.evalTsum._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (mα' : Q(AddCommMonoid «$α»))
(__defeqres : PLift («$zα» =Q «$mα'».toAddZeroClass.toZero)), «$zα» =Q «$mα'».toAddZeroClass.toZero |
MulEquiv.toMagmaCatIso | Mathlib.Algebra.Category.Semigrp.Basic | {X Y : Type u} → [inst : Mul X] → [inst_1 : Mul Y] → X ≃* Y → (MagmaCat.of X ≅ MagmaCat.of Y) |
compl_ne_self._simp_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α} [Nontrivial α], (aᶜ = a) = False |
ValuativeRel.ValueGroupWithZero.lift_valuation | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {α : Sort u_2}
(f : R → ↥(ValuativeRel.posSubmonoid R) → α)
(hf : ∀ (x y : R) (t s : ↥(ValuativeRel.posSubmonoid R)), x * ↑t ≤ᵥ y * ↑s → y * ↑s ≤ᵥ x * ↑t → f x s = f y t)
(x : R), ValuativeRel.ValueGroupWithZero.lift f hf ((ValuativeRel.valuation R) x) = f x 1 |
RingEquiv.toRingCatIso._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (e : R ≃+* S),
CategoryTheory.CategoryStruct.comp (RingCat.ofHom ↑e) (RingCat.ofHom ↑e.symm) =
CategoryTheory.CategoryStruct.id (RingCat.of R) |
Unitization.inl_zero | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_3} (A : Type u_4) [inst : Zero R] [inst_1 : Zero A], Unitization.inl 0 = 0 |
Std.IterStep.mapIterator | Init.Data.Iterators.Basic | {α : Type u} → {β : Type w} → {α' : Type u'} → (α → α') → Std.IterStep α β → Std.IterStep α' β |
List.takeWhile_append_dropWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.takeWhile p l ++ List.dropWhile p l = l |
CategoryTheory.WideSubcategory | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(_P : CategoryTheory.MorphismProperty C) → [_P.IsMultiplicative] → Type u₁ |
_private.Batteries.Data.MLList.Basic.0.MLList.uncons?Impl.match_1 | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} →
{α : Type u_1} →
(motive : MLList.MLListImpl✝ m α → Sort u_2) →
(x : MLList.MLListImpl✝¹ m α) →
(Unit → motive MLList.MLListImpl.nil✝) →
((x : α) → (xs : MLList.MLListImpl✝² m α) → motive (MLList.MLListImpl.cons✝ x xs)) →
((x : MLList.MLListImpl✝³ m α) → motive x) → motive x |
Lean.Meta.Grind.ppPattern | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Expr → Lean.MessageData |
Monoid.PushoutI.NormalWord.rcons.eq_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι) (p : Monoid.PushoutI.NormalWord.Pair d i),
Monoid.PushoutI.NormalWord.rcons i p =
{
toWord :=
(Monoid.CoprodI.Word.equivPair i).symm
(let __src := p.toPair;
{ head := ↑(⋯.equiv p.head).2, tail := __src.tail, fstIdx_ne := ⋯ }),
head := (MonoidHom.ofInjective ⋯).symm (⋯.equiv p.head).1, normalized := ⋯ } |
Submonoid.prod_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_4} [inst : CommMonoid M] (S : Submonoid M) {ι : Type u_5} {t : Finset ι} {f : ι → M},
(∀ c ∈ t, f c ∈ S) → ∏ c ∈ t, f c ∈ S |
Matrix.PosSemidef.diagonal | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : DecidableEq n] {d : n → R}, 0 ≤ d → (Matrix.diagonal d).PosSemidef |
List.map_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l.reverse = (List.map f l).reverse |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.Balanced.map.match_1_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} {t₁ : Std.DTreeMap.Internal.Impl α β}
(motive : (t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.Balanced → t₁ = t₂ → Prop) (t₂ : Std.DTreeMap.Internal.Impl α β)
(x : t₁.Balanced) (x_1 : t₁ = t₂), (∀ (h : t₁.Balanced), motive t₁ h ⋯) → motive t₂ x x_1 |
_private.Mathlib.AlgebraicGeometry.Morphisms.Finite.0.AlgebraicGeometry.IsFinite.instHasAffinePropertyAndIsAffineFiniteCarrierObjOppositeOpensCarrierCarrierCommRingCatPresheafOpOpensTopHomAppTop._simp_1 | Mathlib.AlgebraicGeometry.Morphisms.Finite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.IsFinite f =
(AlgebraicGeometry.IsAffineHom f ∧
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Array Lean.Elab.Tactic.ElimApp.Alt →
Lean.Syntax →
Option (Array Lean.Syntax) →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) →
Lean.Elab.Tactic.TacticM (List Lean.MVarId) |
TopologicalSpace.Opens.coe_disjoint | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Opens α}, Disjoint ↑s ↑t ↔ Disjoint s t |
antitone_const | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {c : β}, Antitone fun x => c |
Polynomial.fiberEquivQuotient._proof_5 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R) [inst_1 : p.IsPrime], IsScalarTower R p.ResidueField p.ResidueField |
Finset.prod_flip | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : CommMonoid M] {n : ℕ} (f : ℕ → M),
∏ r ∈ Finset.range (n + 1), f (n - r) = ∏ k ∈ Finset.range (n + 1), f k |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_of_isSlice._proof_1_5 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} (t : Finset ι) {s : Set (ι → ℕ)} (a : ι → ℕ),
(∀ x ∈ s, ∀ i ∉ t, x i = a i) →
∀ x ∈ s,
∀ (y : ι → ℕ),
y ∈ s ↔ (y ∈ s ∧ ∀ (i : ι), x i ≤ y i) ∨ ∃ i, ∃ (_ : i ∈ t), ∃ i_1, ∃ (_ : i_1 < x i), y ∈ s ∧ y i = i_1 |
CategoryTheory.Functor.shiftMap.eq_1 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] (F : CategoryTheory.Functor C A) {M : Type u_3} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y : C} {n : M}
(f : X ⟶ (CategoryTheory.shiftFunctor C n).obj Y) (a a' : M) (ha' : n + a = a'),
F.shiftMap f a a' ha' = CategoryTheory.CategoryStruct.comp ((F.shift a).map f) ((F.shiftIso n a a' ha').hom.app Y) |
DirectSum.GSemiring.natCast_succ | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} {A : ι → Type u_2} {inst : AddMonoid ι} {inst_1 : (i : ι) → AddCommMonoid (A i)}
[self : DirectSum.GSemiring A] (n : ℕ),
DirectSum.GSemiring.natCast (n + 1) = DirectSum.GSemiring.natCast n + GradedMonoid.GOne.one |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A₁] [inst_4 : CategoryTheory.Category.{v₅, u₅} B₁]
[inst_5 : CategoryTheory.Category.{v₆, u₆} C₁] {F₁ : CategoryTheory.Functor A₁ B₁} {G₁ : CategoryTheory.Functor C₁ B₁}
{X : Type u₇} {Y : Type u₈} [inst_6 : CategoryTheory.Category.{v₇, u₇} X]
[inst_7 : CategoryTheory.Category.{v₈, u₈} Y] (ψ : CategoryTheory.Limits.CatCospanTransform F G F₁ G₁)
(U : CategoryTheory.Functor X Y) (X_1 : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G Y) (x : X),
((CategoryTheory.CatCommSq.iso ((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj U)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Y).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj U)).hom.app
X_1).fst.app
x =
CategoryTheory.CategoryStruct.id (ψ.left.obj (X_1.fst.obj (U.obj x))) |
Pi.isAtom_iff | Mathlib.Order.Atoms | ∀ {ι : Type u_4} {π : ι → Type u} {f : (i : ι) → π i} [inst : (i : ι) → PartialOrder (π i)]
[inst_1 : (i : ι) → OrderBot (π i)], IsAtom f ↔ ∃ i, IsAtom (f i) ∧ ∀ (j : ι), j ≠ i → f j = ⊥ |
AlgebraicGeometry.StructureSheaf.isLocalizedModule_toPushforwardStalkAlgHom_aux | Mathlib.AlgebraicGeometry.Spec | ∀ (R S : CommRingCat) (p : PrimeSpectrum ↑R) [inst : Algebra ↑R ↑S]
(y :
↑(((TopCat.Presheaf.pushforward CommRingCat
(AlgebraicGeometry.Spec.topMap (CommRingCat.ofHom (algebraMap ↑R ↑S)))).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p)),
∃ x, x.2 • y = (AlgebraicGeometry.StructureSheaf.toPushforwardStalkAlgHom R S p) x.1 |
UInt32.ne_of_toBitVec_ne | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toBitVec ≠ b.toBitVec → a ≠ b |
HasFPowerSeriesOnBall.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {f : E → F} {x : E} [CompleteSpace F],
HasFPowerSeriesOnBall f p x r → DifferentiableOn 𝕜 f (Metric.eball x r) |
CategoryTheory.Bicategory.precomp | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] → {a b : B} → (c : B) → (a ⟶ b) → CategoryTheory.Functor (b ⟶ c) (a ⟶ c) |
Padic.padicNormE.image | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ_[p]}, q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n)) |
Lean.Grind.AC.Context.rec | Init.Grind.AC | {α : Sort u} →
{motive : Lean.Grind.AC.Context α → Sort u_1} →
((vars : Lean.RArray (PLift α)) → (op : α → α → α) → motive { vars := vars, op := op }) →
(t : Lean.Grind.AC.Context α) → motive t |
Mathlib.Tactic.TermCongr.mkIffForExpectedType | Mathlib.Tactic.TermCongr | Option Lean.Expr → Lean.MetaM Lean.Expr |
SchwartzMap.ctorIdx | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | {E : Type u_5} →
{F : Type u_6} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} → {inst_2 : NormedAddCommGroup F} → {inst_3 : NormedSpace ℝ F} → SchwartzMap E F → ℕ |
_private.Mathlib.Algebra.ContinuedFractions.TerminatedStable.0.GenContFract.contsAux.match_1.splitter | Mathlib.Algebra.ContinuedFractions.TerminatedStable | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K)) →
(Unit → motive none) → ((gp : GenContFract.Pair K) → motive (some gp)) → motive x |
instCompleteLatticeUniformSpace._proof_6 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (a x x_1 : UniformSpace α), a ≤ x → a ≤ x_1 → UniformSpace.uniformity ≤ uniformity α |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_364 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length] <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
Std.HashSet.filter_equiv_self_iff | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {f : α → Bool},
(Std.HashSet.filter f m).Equiv m ↔ ∀ (k : α) (h : k ∈ m), f (m.get k h) = true |
Subgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.normalCore ≤ H |
lt_of_mul_lt_mul_of_nonneg_right | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosReflectLT α],
b * a < c * a → 0 ≤ a → b < c |
PiTensorProduct.map₂_tprod_tprod | 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} {t' : ι → Type u_12} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] [inst_5 : (i : ι) → AddCommMonoid (t' i)] [inst_6 : (i : ι) → Module R (t' i)]
(f : (i : ι) → s i →ₗ[R] t i →ₗ[R] t' i) (x : (i : ι) → s i) (y : (i : ι) → t i),
((PiTensorProduct.map₂ f) ((PiTensorProduct.tprod R) x)) ((PiTensorProduct.tprod R) y) =
⨂ₜ[R] (i : ι), ((f i) (x i)) (y i) |
CategoryTheory.subcanonical_typesGrothendieckTopology | Mathlib.CategoryTheory.Sites.Types | CategoryTheory.typesGrothendieckTopology.Subcanonical |
CategoryTheory.Limits.CompleteLattice.finiteLimitCone_isLimit_lift | Mathlib.CategoryTheory.Limits.Lattice | ∀ {α : Type u} {J : Type w} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.FinCategory J]
[inst_2 : SemilatticeInf α] [inst_3 : OrderTop α] (F : CategoryTheory.Functor J α) (s : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.CompleteLattice.finiteLimitCone F).isLimit.lift s = CategoryTheory.homOfLE ⋯ |
CauSeq.coe_smul._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {G : Type u_3} [inst_5 : SMul G β]
[inst_6 : IsScalarTower G β β] (a : G) (f : CauSeq β abv), a • ↑f = ↑(a • f) |
StrongDual.extendRCLikeₗ._proof_7 | Mathlib.Analysis.RCLike.Extend | ContinuousConstSMul ℝ ℝ |
CategoryTheory.Limits.Cowedge.ext._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.End | Lean.Syntax |
TensorProduct.directSum._proof_11 | Mathlib.LinearAlgebra.DirectSum.TensorProduct | ∀ (R : Type u_6) [inst : CommSemiring R] (S : Type u_5) [inst_1 : Semiring S] [inst_2 : Algebra R S] {ι₁ : Type u_1}
{ι₂ : Type u_3} [inst_3 : DecidableEq ι₁] [inst_4 : DecidableEq ι₂] (M₁ : ι₁ → Type u_2) (M₂ : ι₂ → Type u_4)
[inst_5 : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)] [inst_6 : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)]
[inst_7 : (i₁ : ι₁) → Module R (M₁ i₁)] [inst_8 : (i₂ : ι₂) → Module R (M₂ i₂)]
[inst_9 : (i₁ : ι₁) → Module S (M₁ i₁)] [inst_10 : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)],
(DirectSum.toModule S (ι₁ × ι₂) (TensorProduct R (DirectSum ι₁ fun i₁ => M₁ i₁) (DirectSum ι₂ fun i₂ => M₂ i₂))
fun i => TensorProduct.AlgebraTensorModule.map (DirectSum.lof S ι₁ M₁ i.1) (DirectSum.lof R ι₂ M₂ i.2)) ∘ₗ
TensorProduct.AlgebraTensorModule.lift
(DirectSum.toModule S ι₁
((DirectSum ι₂ fun i₂ => M₂ i₂) →ₗ[R] DirectSum (ι₁ × ι₂) fun i => TensorProduct R (M₁ i.1) (M₂ i.2))
fun i₁ =>
(DirectSum.toModule R ι₂ (M₁ i₁ →ₗ[S] DirectSum (ι₁ × ι₂) fun i => TensorProduct R (M₁ i.1) (M₂ i.2))
fun i₂ =>
(TensorProduct.AlgebraTensorModule.curry
(DirectSum.lof S (ι₁ × ι₂) (fun i => TensorProduct R (M₁ i.1) (M₂ i.2)) (i₁, i₂))).flip).flip) =
LinearMap.id |
Fin.succAbove_ne_zero_zero | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [inst : NeZero n] {a : Fin (n + 1)}, a ≠ 0 → a.succAbove 0 = 0 |
CategoryTheory.Limits.biconeIsBilimitOfColimitCoconeOfIsColimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
{f : J → C} {t : CategoryTheory.Limits.Cocone (CategoryTheory.Discrete.functor f)}
(ht : CategoryTheory.Limits.IsColimit t) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (t.ι.app j) (CategoryTheory.Iso.refl t.pt).hom =
(CategoryTheory.Limits.Bicone.ofColimitCocone ht).toCocone.ι.app j |
Std.Iter.Total.ctorIdx | Init.Data.Iterators.Consumers.Total | {α β : Type w} → Std.Iter.Total β → ℕ |
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_10 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[inst_10 : LieModule R L N], SMulMemClass (LieSubmodule R L (M →ₗ[R] N)) R (M →ₗ[R] N) |
Lean.Grind.ToInt.Zero.casesOn | Init.Grind.ToInt | {α : Type u} →
[inst : Zero α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Zero α I → Sort u_1} →
(t : Lean.Grind.ToInt.Zero α I) → ((toInt_zero : ↑0 = 0) → motive ⋯) → motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.