name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ULift.algebra | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{A : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra R (ULift.{u_4, u_2} A) | null | true |
SimpleGraph.instSymmFinsetIsUniform | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {G : SimpleGraph α}
[inst_2 : DecidableRel G.Adj] {ε : 𝕜}, Std.Symm (G.IsUniform ε) | null | true |
Polynomial.nthRootsFinset_def | Mathlib.Algebra.Polynomial.Roots | ∀ (n : ℕ) {R : Type u_1} (a : R) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
Polynomial.nthRootsFinset n a = (Polynomial.nthRoots n a).toFinset | null | true |
DirectSum.id._proof_1 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι],
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) 0) = 0 | null | false |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_append._proof_3 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → ¬k - n < m → False | null | false |
CategoryTheory.EquivalenceRelation.recOn | Mathlib.CategoryTheory.EquivalenceRelation | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{R X : C} →
{p₁ p₂ : R ⟶ X} →
{motive : CategoryTheory.EquivalenceRelation p₁ p₂ → Sort u} →
(t : CategoryTheory.EquivalenceRelation p₁ p₂) →
((toReflexiveRelation : CategoryTheory.ReflexiveRelation p₁ p₂) →
... | null | false |
Lean.Order.instMonadTailId._aux_1 | Init.Internal.Order.MonadTail | (x : Type u_1) → [Nonempty x] → Id x → Id x → Prop | null | false |
CategoryTheory.Triangulated.Octahedron.mk.noConfusion | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Preadditive C} →
{inst_2 : CategoryTheory.Limits.HasZeroObject C} →
{inst_3 : CategoryTheory.HasShift C ℤ} →
{inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive} →
{inst_5 : Ca... | null | false |
Primrec.list_cons | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.cons | null | true |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_deriv_norm | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (n : ℕ),
‖(Polynomial.aeval (newton_seq_gen✝ hnorm n)) (Polynomial.derivative F)‖ =
... | null | true |
Std.DTreeMap.Const.getD_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.insertMany t l) k fallback = Std.D... | null | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM.go._unary._proof_2 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} (i : ℕ) (acc : Array α), acc.size = i → ∀ (__do_lift : α), (acc.push __do_lift).size = i + 1 | null | false |
Equiv.coframe._proof_10 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Order.Coframe β] (a b : α), e (e.symm (e a \ e b)) = e a \ e b | null | false |
AlgebraicGeometry.instIsStableUnderCompositionSchemeLocallyOfFiniteType | Mathlib.AlgebraicGeometry.Morphisms.FiniteType | CategoryTheory.MorphismProperty.IsStableUnderComposition @AlgebraicGeometry.LocallyOfFiniteType | null | true |
Pregroupoid.mk._flat_ctor | Mathlib.Geometry.Manifold.StructureGroupoid | {H : Type u_2} →
[inst : TopologicalSpace H] →
(property : (H → H) → Set H → Prop) →
(∀ {f g : H → H} {u v : Set H},
property f u → property g v → IsOpen u → IsOpen v → IsOpen (u ∩ f ⁻¹' v) → property (g ∘ f) (u ∩ f ⁻¹' v)) →
property id Set.univ →
(∀ {f : H → H} {u : Set H}, IsO... | null | false |
CategoryTheory.Presieve.Arrows.Compatible.familyOfElements.congr_simp | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C}
{I : Type u_1} {X : I → C} {π π_1 : (i : I) → X i ⟶ B} (e_π : π = π_1) {x x_1 : (i : I) → P.obj (Opposite.op (X i))}
(e_x : x = x_1) (hx : CategoryTheory.Presieve.Arrows.Compatible P π x) ⦃Y : C⦄ (f f_1 : Y... | null | true |
MeasureTheory.OuterMeasure.mkMetric' | Mathlib.MeasureTheory.Measure.Hausdorff | {X : Type u_2} → [EMetricSpace X] → (Set X → ENNReal) → MeasureTheory.OuterMeasure X | Given a function `m : Set X → ℝ≥0∞`, `mkMetric' m` is the supremum of `mkMetric'.pre m r`
over `r > 0`. Equivalently, it is the limit of `mkMetric'.pre m r` as `r` tends to zero from
the right. | true |
Array.eraseIdxIfInBounds | Init.Data.Array.Basic | {α : Type u} → Array α → ℕ → Array α | Removes the element at a given index from an array. Does nothing if the index is out of bounds.
This function takes worst-case `O(n)` time because it back-shifts all elements at positions greater
than `i`.
Examples:
* `#["apple", "pear", "orange"].eraseIdxIfInBounds 0 = #["pear", "orange"]`
* `#["apple", "pear", "ora... | true |
ArithmeticFunction.instModule._proof_5 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : Module R S] (x : R)
(f g : ArithmeticFunction S), x • (f + g) = x • f + x • g | null | false |
BitVec.instTransOrd | Init.Data.Ord.BitVec | ∀ {n : ℕ}, Std.TransOrd (BitVec n) | null | true |
Fin.preimage_rev_Ioo | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.rev ⁻¹' Set.Ioo i j = Set.Ioo j.rev i.rev | null | true |
Lean.Language.Lean.HeaderProcessedState.casesOn | Lean.Language.Lean.Types | {motive : Lean.Language.Lean.HeaderProcessedState → Sort u} →
(t : Lean.Language.Lean.HeaderProcessedState) →
((cmdState : Lean.Elab.Command.State) →
(firstCmdSnap : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) →
motive { cmdState := cmdState, firstCmdSnap := firstCmdSnap... | null | false |
Nat.map_add_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, Array.map (fun x => x + k) (m<...=n).toArray = ((m + k)<...=n + k).toArray | null | true |
Set.compl_Ioc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (Set.Ioc a b)ᶜ = Set.Iic a ∪ Set.Ioi b | null | true |
Finsupp.instNonUnitalNonAssocRing._proof_6 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalNonAssocRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ | null | false |
Lean.Grind.decide_eq_false | Init.Grind.Lemmas | ∀ {p : Prop} {x : Decidable p}, p = False → decide p = false | null | true |
Std.ExtTreeSet.toArray | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → Array α | Transforms the tree set into an array of elements in ascending order. | true |
CategoryTheory.Bicategory.Pith.pseudofunctorToPithCompInclusionStrongIsoHom._proof_6 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {B' : Type u_2} [inst_1 : CategoryTheory.Bicategory B']
[inst_2 : CategoryTheory.Bicategory.IsLocallyGroupoid B'] (F : CategoryTheory.Pseudofunctor B' B) {a b c : B'}
(f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.... | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_5.splitter | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_2) →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{x y : (CategoryTheory.WithInitial C)ᵒᵖ} →
(motive : (x ⟶ y) → Sort u_3) →
(x_1 : x ⟶ y) → ((f : Opposite.unop y ⟶ Opposite.unop x) → motive (Opposite.op f)) → motive x_1 | null | true |
RBTree.RBNode.del.eq_def | BatteriesRecycling.RBTree.WF | ∀ {α : Type u_1} (cut : α → Ordering) (x : RBTree.RBNode α),
RBTree.RBNode.del cut x =
match x with
| RBTree.RBNode.nil => RBTree.RBNode.nil
| RBTree.RBNode.node c a y b =>
match cut y with
| Ordering.lt =>
match a.isBlack with
| RBTree.RBColor.black => (RBTree.RBNode.del cut a... | null | true |
Mathlib.Tactic.Order.AtomicFact.lt | Mathlib.Tactic.Order.CollectFacts | ℕ → ℕ → Lean.Expr → Mathlib.Tactic.Order.AtomicFact | null | true |
CategoryTheory.Limits.Cotrident.ext._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {s t : CategoryTheory.Limits.Cotrident f} (i : s.pt ≅ t.pt)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cotrident.... | null | false |
CategoryTheory.Functor.isRightAdjoint_comp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} [F.IsRightAdjoint] [G.IsRightAdjoint], (F.comp G).IsRightAdjoint | If `F` and `G` are right adjoints then `F ⋙ G` is a right adjoint too. | true |
alternatingGroup.normal | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], (alternatingGroup α).Normal | null | true |
Array.forIn'_yield_eq_foldlM | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
(f : (a : α) → a ∈ xs → β → m γ) (g : (a : α) → a ∈ xs → β → γ → β) (init : β),
(forIn' xs init fun a m_1 b => (fun c => ForInStep.yield (g a m_1 b c)) <$> f a m_1 b) =
Array.foldlM
(fun b x =>
... | We can express a for loop over an array which always yields as a fold. | true |
SemimoduleCat.MonoidalCategory.associator | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | {R : Type u} →
[inst : CommSemiring R] →
(M : SemimoduleCat R) →
(N : SemimoduleCat R) →
(K : SemimoduleCat R) →
SemimoduleCat.MonoidalCategory.tensorObj (SemimoduleCat.MonoidalCategory.tensorObj M N) K ≅
SemimoduleCat.MonoidalCategory.tensorObj M (SemimoduleCat.MonoidalCategor... | (implementation) the associator for R-modules | true |
Std.Sat.AIG.CacheHit.casesOn | Std.Sat.AIG.Basic | {α : Type} →
{decls : Array (Std.Sat.AIG.Decl α)} →
{decl : Std.Sat.AIG.Decl α} →
{motive : Std.Sat.AIG.CacheHit decls decl → Sort u} →
(t : Std.Sat.AIG.CacheHit decls decl) →
((idx : ℕ) →
(hbound : idx < decls.size) →
(hvalid : decls[idx] = decl) → motive { i... | null | false |
AddUnits.val_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α], ↑0 = 0 | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.eval | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : Type u_1} → {β : Type u_2} → [Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → (α → Bool) → β → Bool | null | true |
Std.Time.TimeZone | Std.Time.Zoned.TimeZone | Type | A TimeZone structure that stores the timezone offset, the name, abbreviation and if it's in daylight
saving time.
| true |
Std.TreeSet.foldr_eq_foldr_toArray | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {f : α → δ → δ} {init : δ},
Std.TreeSet.foldr f init t = Array.foldr f init t.toArray | null | true |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk._proof_2 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} C] [inst_2 : CategoryTheory.Limits.HasTerminal C] {c : C}
(U : (TopologicalSpace.OpenNhds p₀)ᵒᵖ), (if p₀ ∈ ↑(Opposite.unop U) then c else ⊤_ C) = c | null | false |
Stream'.Seq.Corec.f.match_1 | Mathlib.Data.Seq.Defs | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x | null | false |
String.Pos.revSkip?_bool_eq_none_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {pos : s.Pos},
(pos.revSkip? p = none) = ∀ (h : pos ≠ s.startPos), p ((pos.prev h).get ⋯) = false | null | false |
RCLike.re_eq_complex_re | Mathlib.Analysis.Complex.Basic | ⇑RCLike.re = Complex.re | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (a b toIntThm : Lean.Expr) (lhs rhs : Int.Linear.Expr) (a_1 b_1 toIntThm_1 : Lean.Expr)
(lhs_1 rhs_1 : Int.Linear.Expr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a b toIntThm lhs rhs =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a_1 b_1 toIntThm_1 lhs_1 rhs_1) =
(a = a_1 ∧ b = ... | null | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.ConstantInfo.isDef.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.ConstantInfo → Sort u_1) →
(x : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((x : Lean.ConstantInfo) → motive x) → motive x | null | false |
Prime.nat_prime | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Prime p → Nat.Prime p | **Alias** of the reverse direction of `Nat.prime_iff`. | true |
Aesop.GoalData.lastExpandedInIteration | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.Iteration | null | true |
isCycle_finRotate_of_le | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ}, 2 ≤ n → (finRotate n).IsCycle | null | true |
Lean.Grind.CommRing.Expr.toPolyC.go._unsafe_rec | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | null | false |
Bundle.Pretrivialization.continuousOn_continuousLinearMapCoordChange | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_1} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_2} [inst_1 : NontriviallyNormedField 𝕜₂]
{σ : 𝕜₁ →+* 𝕜₂} {B : Type u_3} {F₁ : Type u_4} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_5} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | null | true |
CategoryTheory.Limits.BinaryBicone.ofColimitCocone._proof_8 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t),
CategoryTheory.CategoryStruct.comp (t.ι.app { as := CategoryTheory.Limits.WalkingPair.right }... | null | false |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.exists_lt_omega0_opow' | Mathlib.SetTheory.Ordinal.Notation | ∀ {α : Sort u_1} {o b : Ordinal.{u_2}},
1 < b →
Order.IsSuccLimit o →
∀ {f : α → Ordinal.{u_2}},
(∀ ⦃a : Ordinal.{u_2}⦄, a < o → ∃ i, a < f i) → ∀ ⦃a : Ordinal.{u_2}⦄, a < b ^ o → ∃ i, a < b ^ f i | null | true |
OpenPartialHomeomorph.contDiff_unitBallBall | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ {n : ℕ∞} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {c : E} {r : ℝ} (hr : 0 < r),
ContDiff ℝ ↑n ↑(OpenPartialHomeomorph.unitBallBall c r hr) | null | true |
StarRingEquivClass.toStarRingEquiv.congr_simp | Mathlib.Algebra.Star.StarAlgHom | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : Add A] [inst_1 : Mul A] [inst_2 : Star A] [inst_3 : Add B]
[inst_4 : Mul B] [inst_5 : Star B] [inst_6 : EquivLike F A B] [inst_7 : StarRingEquivClass F A B] (f f_1 : F),
f = f_1 → ↑f = ↑f_1 | null | true |
Algebra.RingHom.adjoinAlgebraMap.congr_simp | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring A] [inst_1 : CommSemiring B]
[inst_2 : CommSemiring C] [inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C]
[inst_6 : IsScalarTower A B C] (b : B), Algebra.RingHom.adjoinAlgebraMap b = Algebra.RingHom.adjoinAlgebraMap b | null | true |
EReal.coe_zsmul | Mathlib.Data.EReal.Operations | ∀ (n : ℤ) (x : ℝ), ↑(n • x) = n • ↑x | null | true |
Std.Roc.toList_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α], r.toArray.toList = r.toList | null | true |
_private.Mathlib.Logic.Relation.0.Relation.map_onFun_map_eq_map._proof_1_2 | Mathlib.Logic.Relation | ∀ {α : Sort u_2} {β : Sort u_1} {r : α → α → Prop} (f : α → β),
Relation.Map (fun x y => Relation.Map r f f (f x) (f y)) f f = Relation.Map r f f | null | false |
PairReduction.edist_le_of_mem_pairSet | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {n : ℕ} {J : Finset T} [inst_1 : DecidableEq T],
1 < a → ↑J.card ≤ a ^ n → ∀ {s t : T}, (s, t) ∈ PairReduction.pairSet J a c → edist s t ≤ ↑n * c | null | true |
CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom' | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C) {Y Z : C}
(f : Y ⟶ Z) [inst_2 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.inv f))
(CategoryTheory.MonoidalCategor... | null | true |
TopCat.Path.hom₁._autoParam | Mathlib.Topology.Homotopy.TopCat.Path | Lean.Syntax | null | false |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.testTacticSeq._sparseCasesOn_9 | Mathlib.Tactic.TacticAnalysis | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicGeometry.PresheafedSpace.Hom.mk._flat_ctor | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : AlgebraicGeometry.PresheafedSpace C} →
(base : ↑X ⟶ ↑Y) → (Y.presheaf ⟶ (TopCat.Presheaf.pushforward C base).obj X.presheaf) → X.Hom Y | null | false |
Option.forIn_yield_eq_elim | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] (o : Option α)
(f : α → β → m γ) (g : α → β → γ → β) (b : β),
(forIn o b fun a b => (fun c => ForInStep.yield (g a b c)) <$> f a b) = o.elim (pure b) fun a => g a b <$> f a b | null | true |
Real.tan_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.tan (Real.arccos x) = √(1 - x ^ 2) / x | null | true |
Lean.Grind.ToInt.wrap_toInt | Init.Grind.ToInt | ∀ {α : Type u_1} (I : Lean.Grind.IntInterval) [inst : Lean.Grind.ToInt α I] (x : α), I.wrap ↑x = ↑x | null | true |
_private.Init.Data.Option.Lemmas.0.Option.not_rel_none_some.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {a : β} {r : α → β → Prop} (motive : Option.Rel r none (some a) → Prop)
(a : Option.Rel r none (some a)), motive a | null | false |
Language.isRegular_iff_finite_range_leftQuotient | Mathlib.Computability.MyhillNerode | ∀ {α : Type u} {L : Language α}, L.IsRegular ↔ (Set.range L.leftQuotient).Finite | **Myhill–Nerode theorem**. A language is regular if and only if the set of left quotients is finite.
| true |
Algebra.TensorProduct.mul | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalNonAssocSemiring B] →
[i... | (Implementation detail)
The multiplication map on `A ⊗[R] B`,
as an `R`-bilinear map.
| true |
CategoryTheory.ExponentiableMorphism.unit_pushforwardComp_hom_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J K : C} (f : I ⟶ J) (g : J ⟶ K)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ChosenPullbacksAlong g]
[inst_3 : CategoryTheory.ChosenPullbacksAlong (CategoryTheory.CategoryStruct.comp f g)]
[inst_4 : CategoryTheory.Exponentia... | null | true |
_private.Lean.Widget.InteractiveGoal.0.Lean.Widget.withGoalCtx.match_1 | Lean.Widget.InteractiveGoal | (motive : Option Lean.MetavarDecl → Sort u_1) →
(x : Option Lean.MetavarDecl) →
((mvarDecl : Lean.MetavarDecl) → motive (some mvarDecl)) → ((x : Option Lean.MetavarDecl) → motive x) → motive x | null | false |
ContinuousMultilinearMap.alternatization._proof_3 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_4} {M : Type u_1} {N : Type u_2} {ι : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N] [inst_8 : Fintype ι] [inst_9 : DecidableEq... | null | false |
Lean.Meta.DiagSummary._sizeOf_inst | Lean.Meta.Diagnostics | SizeOf Lean.Meta.DiagSummary | null | false |
CategoryTheory.BiconeHom.decidableEq._proof_11 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J]
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.right CategoryTheory.Bicone.right), g ≍ g | null | false |
BitVec.ofNat_toNat | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} (m : ℕ) (x : BitVec n), BitVec.ofNat m x.toNat = BitVec.setWidth m x | null | true |
AlgebraicGeometry.Scheme.instAbelianSheafEtaleSmallEtaleTopology | Mathlib.AlgebraicGeometry.Sites.AffineEtale | {S : AlgebraicGeometry.Scheme} →
{A : Type u'} →
[inst : CategoryTheory.Category.{u, u'} A] →
{FA : A → A → Type u_1} →
{CD : A → Type u} →
[inst_1 : (X Y : A) → FunLike (FA X Y) (CD X) (CD Y)] →
[inst_2 : CategoryTheory.ConcreteCategory A FA] →
[CategoryTheory.Li... | null | true |
UInt16.neg_neg | Init.Data.UInt.Lemmas | ∀ {a : UInt16}, - -a = a | null | true |
Lean.Meta.Match.MatcherInfo.noConfusion | Lean.Meta.Match.MatcherInfo | {P : Sort u} → {t t' : Lean.Meta.MatcherInfo} → t = t' → Lean.Meta.Match.MatcherInfo.noConfusionType P t t' | null | false |
CategoryTheory.MonoidalCoherence.right'_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
[inst_2 : CategoryTheory.MonoidalCoherence X Y],
CategoryTheory.MonoidalCoherence.iso =
CategoryTheory.MonoidalCoherence.iso ≪≫ (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).symm | null | true |
_private.Init.Data.List.Perm.0.List.perm_middle.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (b : α) (tail x : List α), motive (b :: tail) x) → motive x x_1 | null | false |
Lean.Elab.Term.Do.ToTerm.Kind._sizeOf_1 | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind → ℕ | null | false |
Lean.Parser.Command.macroArg.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
Filter.HasBasis.lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {γ : Type u_3} {ι : Type u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α},
f.HasBasis p s →
∀ {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ},
(∀ (i : ι), (g (s i)).HasBasis (pg i) (sg i)) →
Monotone g → (f.lift g).HasBasis (fun i... | If `(p : ι → Prop, s : ι → Set α)` is a basis of a filter `f`, `g` is a monotone function
`Set α → Filter γ`, and for each `i`, `(pg : β i → Prop, sg : β i → Set α)` is a basis
of the filter `g (s i)`, then
`(fun (i : ι) (x : β i) ↦ p i ∧ pg i x, fun (i : ι) (x : β i) ↦ sg i x)`
is a basis of the filter `f.lift g`.
Th... | true |
CoalgebraStruct.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] → (A →ₗ[R] TensorProduct R A A) → (A →ₗ[R] R) → CoalgebraStruct R A | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.filterMap._proof_9 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | null | false |
CategoryTheory.ShortComplex.Homotopy.symm_h₀ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
h.symm.h₀ = -h.h₀ | null | true |
Array.Matcher.Iterator.noConfusion | Batteries.Data.Array.Match | {P : Sort u} →
{σ : Type u_1} →
{n : Type u_1 → Type u_2} →
{α : Type u_1} →
{inst : BEq α} →
{m : Array.Matcher α} →
{inst_1 : Std.Iterator σ n α} →
{t : Array.Matcher.Iterator σ n α m} →
{σ' : Type u_1} →
{n' : Type u_1 → Type u... | null | false |
Convexity.map_iConvexComb | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u_1} {I : Type u_6} {J : Type u_7} {K : Type u_8} [inst : PartialOrder R] [inst_1 : Semiring R]
[inst_2 : IsStrictOrderedRing R] {f : J → K} (s : Convexity.StdSimplex R I) (g : I → Convexity.StdSimplex R J),
Convexity.StdSimplex.map f (Convexity.iConvexComb s g) = Convexity.iConvexComb s (Convexity.StdS... | null | true |
QuadraticModuleCat.ofIso._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : AddCommGroup X] [inst_2 : Module R X]
[inst_3 : AddCommGroup Y] [inst_4 : Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y}
(e : QuadraticMap.IsometryEquiv Q₁ Q₂),
CategoryTheory.CategoryStruct.comp (QuadraticModuleCat.ofHom e.symm.toIsom... | null | false |
Batteries.CodeAction.startTacticStub | Batteries.CodeAction.Misc | Lean.CodeAction.HoleCodeAction | Invoking hole code action "Start a tactic proof" will fill in a hole with `by done`. | true |
PrimeMultiset.prod_dvd_prod | Mathlib.Data.PNat.Factors | ∀ {u v : PrimeMultiset}, u ≤ v → u.prod ∣ v.prod | **Alias** of the reverse direction of `PrimeMultiset.prod_dvd_iff`. | true |
Lean.Meta.Sym.DSimp.Result.ctorIdx | Lean.Meta.Sym.DSimp.DSimpM | Lean.Meta.Sym.DSimp.Result → ℕ | null | false |
AlgebraicGeometry.ExistsHomHomCompEqCompAux._sizeOf_inst | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
(D : CategoryTheory.Functor I AlgebraicGeometry.Scheme) →
(t : D ⟶ (CategoryTheory.Functor.const I).obj S) →
(f : X ⟶ S) → [SizeOf I] → SizeOf (AlgebraicGeometry.ExistsHomHomCompEqCompAux D t f) | null | false |
SSet.Truncated.liftOfStrictSegal.spineEquiv_f₂_arrow_one | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X Y : SSet.Truncated 2}
(f₀ :
X.obj (Opposite.op { obj := { len := 0 }, property := _proof_11✝ }) →
Y.obj (Opposite.op { obj := { len := 0 }, property := _proof_11✝ }))
(f₁ :
X.obj (Opposite.op { obj := { len := 1 }, property := _proof_12✝ }) →
Y.obj (Opposite.op { obj := { len := 1 }, proper... | null | true |
_private.Aesop.Forward.LevelIndex.0.Aesop.instHashableLevelIndex.hash.match_1 | Aesop.Forward.LevelIndex | (motive : Aesop.LevelIndex → Sort u_1) → (x : Aesop.LevelIndex) → ((a : ℕ) → motive { toNat := a }) → motive x | null | false |
Set.Icc_subset_Icc_union_Icc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Icc a c ⊆ Set.Icc a b ∪ Set.Icc b c | null | true |
CoheytingHom.id._proof_2 | Mathlib.Order.Heyting.Hom | ∀ (α : Type u_1) [inst : CoheytingAlgebra α] (x x_1 : α),
(LatticeHom.id α).toFun (x \ x_1) = (LatticeHom.id α).toFun (x \ x_1) | null | false |
Lean.Elab.Term.Do.ToTerm.Context.rec | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Context → Sort u} →
((m returnType : Lean.Syntax) →
(uvars : Array Lean.Elab.Term.Do.Var) →
(kind : Lean.Elab.Term.Do.ToTerm.Kind) →
motive { m := m, returnType := returnType, uvars := uvars, kind := kind }) →
(t : Lean.Elab.Term.Do.ToTerm.Context) → moti... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.