name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.EnrichedFunctor.obj | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} → [inst_3 : CategoryTheory.EnrichedCategory V D] → CategoryTheory.EnrichedFunctor V C D → C → D | The application of this functor to an object | true |
iteratedDeriv_div_const | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_6} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {n : ℕ} (f : 𝕜 → 𝕜') (c : 𝕜'),
iteratedDeriv n (fun x => f x / c) x = iteratedDeriv n f x / c | null | true |
_private.Mathlib.Data.List.Dedup.0.List.dedup_cons_of_mem'._simp_1_2 | Mathlib.Data.List.Dedup | ∀ {a : Prop}, (¬¬a) = a | null | false |
MvQPF.Comp.map' | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} →
{G : Fin2 n → TypeVec.{u} m → Type u} →
{α β : TypeVec.{u} m} → α.Arrow β → [(i : Fin2 n) → MvFunctor (G i)] → TypeVec.Arrow (fun i => G i α) fun i => G i β | map operation defined on a vector of functors | true |
Std.TreeMap.contains_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.insert k v).contains k = true | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.chain_of_pairwise._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {r : α → α → Prop} (a : α) (l : List α),
(∀ a_1 ∈ ↑(a :: l), ∀ b ∈ ↑(a :: l), r a_1 b) →
a ∈ ↑(a :: l) → (∀ {b : α}, b ∈ l → b ∈ ↑(a :: l)) → ∀ b ∈ l ++ [a], r a b | null | false |
EIO.catchExceptions | Init.System.IO | {ε α : Type} → EIO ε α → (ε → BaseIO α) → BaseIO α | Handles any exception that might be thrown by an `EIO ε` action, transforming it into an
exception-free `BaseIO` action.
| true |
NNReal.toReal_ne._simp_1 | Mathlib.Basic.NNReal.Basic | ∀ (a b : NNReal), (a ≠ b) = (↑a ≠ ↑b) | null | false |
ContinuousAffineMap.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Affine | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E →ᴬ[𝕜] F)
{s : Set E}, DifferentiableOn 𝕜 (⇑f) s | null | true |
_private.Lean.Syntax.0.Lean.Syntax.isQuot._sparseCasesOn_2 | Lean.Syntax | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
IsometricContinuousFunctionalCalculus.casesOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Ring A] →
[inst_6 : StarR... | null | false |
Lean.Parser.longestMatchFnAux | Lean.Parser.Basic | Option Lean.Syntax → ℕ → ℕ → String.Pos.Raw → ℕ → List (Lean.Parser.Parser × ℕ) → Lean.Parser.ParserFn | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Saturation.0.Submonoid.mem_saturation_iff.match_1_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : CommMonoid M] {s : Submonoid M} {x : M} (motive : (∃ y, x * y ∈ s) → Prop)
(x_1 : ∃ y, x * y ∈ s), (∀ (y : M) (hxy : x * y ∈ s), motive ⋯) → motive x_1 | null | false |
Aesop.Goal.lastExpandedInIteration | Aesop.Tree.Data | Aesop.Goal → Aesop.Iteration | null | true |
Equiv.Perm.disjoint_of_disjoint_support | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] {H K : Subgroup (Equiv.Perm α)},
(∀ a ∈ H, ∀ b ∈ K, Disjoint a.support b.support) → Disjoint H K | null | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_10 | Mathlib.Analysis.Complex.JensenFormula | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
Setoid.completeLattice._proof_4 | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Setoid α), x ≤ x_1 → x ≤ x_2 → ∀ (x_3 x_4 : α), x x_3 x_4 → x_1 x_3 x_4 ∧ x_2 x_3 x_4 | null | false |
List.orderedInsert._unsafe_rec | Mathlib.Data.List.Sort | {α : Type u_1} → (r : α → α → Prop) → [DecidableRel r] → α → List α → List α | null | false |
AffineAddMonoid.dim | Mathlib.Algebra.AffineMonoid.Embedding | (M : Type u_1) → [AddCancelCommMonoid M] → ℕ | The dimension of an affine monoid `M`, namely the minimum `n` for which `M` embeds into `ℤⁿ`. | true |
Filter.HasBasis.comap | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_3} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (f : β → α),
l.HasBasis p s → (Filter.comap f l).HasBasis p fun i => f ⁻¹' s i | null | true |
PresheafOfModules.hasColimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
[CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, v, v + 1} AddCommGrpCat],
CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (PresheafOfModules R) | null | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.mem_append_stream_right.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} (motive : (x : α) → List α → (x_2 : Stream' α) → x ∈ x_2 → Prop) (x : α) (x_1 : List α)
(x_2 : Stream' α) (x_3 : x ∈ x_2),
(∀ (x : α) (x_4 : Stream' α) (h : x ∈ x_4), motive x [] x_4 h) →
(∀ (a head : α) (l : List α) (s : Stream' α) (h : a ∈ s), motive a (head :: l) s h) → motive x x_1 x_2 x_3 | null | false |
AddMonoidHom.mkRingHomOfMulSelfOfTwoNeZero._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommRing α] [inst_1 : CommRing β] (f : β →+ α) (x y : β),
(↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | null | false |
instUniqueSumsFinsupp | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddZeroClass G] [UniqueSums G], UniqueSums (ι →₀ G) | null | true |
Std.ExtTreeSet.contains_iff_mem | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true ↔ k ∈ t | null | true |
Std.TreeSet.getD_inter_of_not_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ ∩ t₂).getD k fallback = fallback | null | true |
CommRingCat.Colimits.Prequotient.add.elim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
t.ctorIdx = 4 → ((a a_1 : CommRingCat.Colimits.Prequotient F) → motive (a.add a_1)) → mo... | null | false |
_private.Lean.DocString.Add.0.Lean.addDocString'.match_1 | Lean.DocString.Add | (motive : Option (Lean.TSyntax `Lean.Parser.Command.docComment) → Sort u_1) →
(docString? : Option (Lean.TSyntax `Lean.Parser.Command.docComment)) →
((docString : Lean.TSyntax `Lean.Parser.Command.docComment) → motive (some docString)) →
(Unit → motive none) → motive docString? | null | false |
Int32.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int32), a &&& b &&& c = a &&& (b &&& c) | null | true |
CategoryTheory.Abelian.SpectralObject.descE._proof_7 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₁₂ : i ⟶ k)
(h₁₂ : CategoryTheory.CategoryStruct.... | null | false |
Nat.card_units | Mathlib.Algebra.GroupWithZero.Units.Fintype | ∀ (α : Type u_1) [inst : GroupWithZero α], Nat.card αˣ = Nat.card α - 1 | null | true |
Set.wellFoundedOn_empty | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} (r : α → α → Prop), ∅.WellFoundedOn r | null | true |
IsAdjoinRoot.adjoinRootAlgEquiv._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S],
RingHomClass (Polynomial R →ₐ[R] S) (Polynomial R) S | null | false |
Std.Sat.AIG.RefVec.get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).get idx hidx = (s.get idx hidx).cast hcast | null | true |
Lean.getProjFnInfoForField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option (Lean.Name × Lean.ProjectionFunctionInfo) | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int8), i.toInt + ↑n ≤ Int8.maxValueSealed✝.toInt → i.toInt + ↑n ≤ Int8.maxValue.toInt | null | false |
Mathlib.Tactic.ClickSuggestions.SectionKind.currFile.sizeOf_spec | Mathlib.Tactic.ClickSuggestions.SectionState | sizeOf Mathlib.Tactic.ClickSuggestions.SectionKind.currFile = 1 | null | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | {F : Type u_1} → [inst : NormedRing F] → [NormedAlgebra ℝ F] → F → ℝ × ℝ → F | A (private) abbreviation introduced for conciseness below.
We will show that for every `x : F`, `φ x` takes the value zero. | true |
ContinuousLinearMap.norm_smulRightL_le | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {E : Type u_5} {Fₗ : Type u_7} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup Fₗ]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 Fₗ],
‖ContinuousLinearMap.smulRightL 𝕜 E Fₗ‖ ≤ 1 | null | true |
Lean.Meta.Simp.getSimprocFromDeclImpl | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Lean.ImportM (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc) | null | true |
Finset.prod_insert' | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} {a : ι} [inst : CommMonoid M] [inst_1 : DecidableEq ι],
a ∉ s → (insert a s).prod = fun f => f a * ∏ x ∈ s, f x | Variant of `prod_insert` not applied to a function. | true |
_private.Std.Http.Data.Headers.Basic.0.Std.Http.Header.instBEqHost.beq.match_1 | Std.Http.Data.Headers.Basic | (motive : Std.Http.Header.Host → Std.Http.Header.Host → Sort u_1) →
(x x_1 : Std.Http.Header.Host) →
((a : Std.Http.URI.Host) →
(a_1 : Std.Http.URI.Port) →
(b : Std.Http.URI.Host) →
(b_1 : Std.Http.URI.Port) → motive { host := a, port := a_1 } { host := b, port := b_1 }) →
((x ... | null | false |
ProofWidgets.InteractiveCodeProps.noConfusionType | ProofWidgets.Component.Basic | Sort u → ProofWidgets.InteractiveCodeProps → ProofWidgets.InteractiveCodeProps → Sort u | null | false |
_private.Lean.Parser.Extra.0.Lean.Parser.ppRealGroup._regBuiltin.Lean.Parser.ppRealGroup.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
CategoryTheory.rightDistributor_ext₂_right | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {f : J → C} {X Y Z : C}
{g h :
X ⟶ Ca... | null | true |
Padic.AddValuation.map_zero | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], Padic.addValuationDef 0 = ⊤ | null | true |
Matrix.GeneralLinearGroup.congr_simp | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Projective | ∀ (n : Type u) (R : Type v) {inst : DecidableEq n} [inst_1 : DecidableEq n] [inst_2 : Fintype n] [inst_3 : Semiring R],
GL n R = GL n R | null | true |
Lean.Lsp.ParameterInformationLabel.name.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {name name_1 : String},
Lean.Lsp.ParameterInformationLabel.name name = Lean.Lsp.ParameterInformationLabel.name name_1 → name = name_1 | null | true |
CompactExhaustion._sizeOf_inst | Mathlib.Topology.Compactness.SigmaCompact | (X : Type u_4) → {inst : TopologicalSpace X} → [SizeOf X] → SizeOf (CompactExhaustion X) | null | false |
DirichletCharacter.changeLevel._proof_1 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n m : ℕ} (hm : n ∣ m),
MulChar.ofUnitHom ((MulChar.toUnitHom 1).comp (ZMod.unitsMap hm)) = 1 | null | false |
Orientation.areaForm'._proof_12 | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E], ContinuousSMul ℝ (E →L[ℝ] ℝ) | null | false |
_private.Mathlib.Algebra.Group.Center.0.Set.center_prod._simp_1_2 | Mathlib.Algebra.Group.Center | ∀ {M : Type u_2} [inst : Mul M] (a b : M), Commute a b = (a * b = b * a) | null | false |
DFinsupp.lex_lt_of_lt | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
(r : ι → ι → Prop) [IsStrictOrder ι r] {x y : Π₀ (i : ι), α i}, x < y → Pi.Lex r (fun {i} x1 x2 => x1 < x2) ⇑x ⇑y | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.Ref.seen | Lean.Elab.DocString | {α : Sort u_1} → Lean.Doc.Ref✝ α → Bool | null | true |
LinearMap.toAddMonoidHom_proj | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] (i : ι), (LinearMap.proj i).toAddMonoidHom = Pi.evalAddMonoidHom φ i | null | true |
Std.TreeMap.instSliceableRoiSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
Std.HashMap.toArray_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m.keysIter.toArray = m.keysArray | null | true |
Std.Http.URI.EncodedQueryString.ofByteArray? | Std.Http.Data.URI.Encoding | ByteArray →
(r : optParam (UInt8 → Bool) Std.Http.Internal.Char.isQueryChar) → Option (Std.Http.URI.EncodedQueryString r) | Attempts to create an `EncodedQueryString` from a `ByteArray`. Returns `some` if the byte array contains
only valid encoded query characters and all percent signs are followed by exactly two hex digits, `none` otherwise.
| true |
Finset.tendsto_Ico_neg_atTop_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : LocallyFiniteOrder α] [NoTopOrder α], Filter.Tendsto (fun a => Finset.Ico (-a) a) Filter.atTop Filter.atTop | null | true |
Lean.Meta.Grind.EMatchTheorem.numParams | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheorem → ℕ | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₂₃ : j ⟶ l)
(h₂₃ : CategoryTheory.CategoryStruct.... | null | true |
Std.HashMap.Raw.getKey!_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited α], m.WF → ∀ {k k' : α}, (k == k') = true → m.getKey! k = m.getKey! k' | null | true |
QuaternionGroup.ctorElimType | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} → {motive : QuaternionGroup n → Sort u} → ℕ → Sort (max 1 u) | null | false |
FirstOrder.Language.Sentence.realize_cardGe._simp_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) {M : Type w} [inst : L.Structure M] (n : ℕ),
M ⊨ FirstOrder.Language.Sentence.cardGe L n = (↑n ≤ Cardinal.mk M) | null | false |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1.eq_2 | Mathlib.Algebra.Order.Ring.Abs | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
Std.TreeSet.Raw.min?_eq_some_iff_get?_eq_self_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.min? = some km ↔ t.get? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true | null | true |
SimpleGraph.isNClique_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {n : ℕ} {s : Finset α}, G.IsNClique n s ↔ G.IsClique ↑s ∧ s.card = n | null | true |
BitVec.toFin_mul | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n), (x * y).toFin = x.toFin * y.toFin | null | true |
CategoryTheory.Functor.CommShift.OfComp.iso | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D ... | Auxiliary definition for `Functor.CommShift.ofComp`. | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Bilinear.0.IsBoundedBilinearMap.hasStrictFDerivAt._abel_1_4 | Mathlib.Analysis.Calculus.FDeriv.Bilinear | ∀ {E : Type u_2} {F : Type u_3} {G : Type u_1} [inst : NormedAddCommGroup G] {b : E × F → G} (x₁ : E) (y₁ : F) (x₂ : E)
(y₂ : F) (x : E) (y : F),
b (x, y) + b (x₁, y) + (b (x, y₁) + b (x₁, y₁)) - (b (x, y) + b (x₂, y) + (b (x, y₂) + b (x₂, y₂))) -
(b (x, y) + b (x, y₁) + (b (x, y) + b (x₁, y)) - (b (x, y) + b... | null | false |
CategoryTheory.AddMod.comap_obj_X | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{A B : C} [inst_4 : CategoryTheory.AddMonObj A] [inst_5 : CategoryTheory.AddMonObj B]... | null | true |
Graph.IsSubgraph.isNonloopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsNonloopAt e x ↔ G.IsNonloopAt e x) | null | true |
Std.Http.Method.proppatch | Std.Http.Data.Method | Std.Http.Method | Set or remove properties on a resource (WebDAV).
Source: https://www.rfc-editor.org/rfc/rfc4918#section-9.2
| true |
UpperHalfPlane.periodic_comp_ofComplex | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | ∀ {f : UpperHalfPlane → ℂ} {h : ℝ},
(∀ (τ : UpperHalfPlane), f (h +ᵥ τ) = f τ) → Function.Periodic (f ∘ ↑UpperHalfPlane.ofComplex) ↑h | null | true |
Std.PRange.UpwardEnumerable.succMany_succ | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany (n + 1) a = Std.PRange.succ (Std.PRange.succMany n a) | null | true |
_private.Lean.LibrarySuggestions.Basic.0.Lean.Expr.FoldRelevantConstantsImpl.ArgKind.value | Lean.LibrarySuggestions.Basic | Lean.Expr.FoldRelevantConstantsImpl.ArgKind✝ | The parameter type is never a proposition, so the argument is not a proof. It is visited. | true |
ENNReal.image_coe_Ioi | Mathlib.Basic.ENNReal.Operations | ∀ (x : NNReal), ENNReal.ofNNReal '' Set.Ioi x = Set.Ioo ↑x ⊤ | null | true |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isMeta._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) → motive Lean.Elab.ComputeKind.meta → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.MethodsRefPointed | Lean.Meta.Tactic.Grind.Types | NonemptyType | null | true |
ClosedSubmodule.mk.noConfusion | Mathlib.Topology.Algebra.Module.ClosedSubmodule | {R : Type u_2} →
{M : Type u_3} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : TopologicalSpace M} →
{inst_3 : Module R M} →
{P : Sort u} →
{toSubmodule : Submodule R M} →
{isClosed' : IsClosed toSubmodule.carrier} →
... | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry?.match_1.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Sort u_3) (k : α) (v : β k)
(l : List ((a : α) × β a)) (h_1 : Unit → motive [])
(h_2 : (k : α) → (v : β k) → (l : List ((a : α) × β a)) → motive (⟨k, v⟩ :: l)),
(match ⟨k, v⟩ :: l with
| [] => h_1 ()
| ⟨k, v⟩ :: l => h_2 k v l) =
h_2... | null | true |
EuclideanGeometry.oangle_sub_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p p₁ p₂ p₃ : P},
p₁ ≠ p →
p₂ ≠ p →
p₃ ≠ p → EuclideanGeometry.oangle p₁ p p... | Given three points not equal to `p`, the angle between the first and the third at `p` minus
the angle between the second and the third equals the angle between the first and the second. | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Integral.0.MeasureTheory.VectorMeasure.integral_neg_cbm._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{T : Set α → E →L[ℝ] F} {C : ℝ} (hT : MeasureTheory.DominatedFinMeasAdditive μ T C) (f : α → E),
... | null | false |
HasEnoughRootsOfUnity.exists_isPrimitiveRoot | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [HasEnoughRootsOfUnity M n], ∃ ζ, IsPrimitiveRoot ζ n | null | true |
aeSeq.eq_1 | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} (hf : ∀ (i : ι), AEMeasurable (f i) μ) (p : α → (ι → β) → Prop) (i : ι) (x : α),
aeSeq hf p i x = if x ∈ aeSeqSet hf p then AEMeasurable.mk (f i) ⋯ x else ⋯.some | null | true |
TendstoLocallyUniformly.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {l : Filter ι},
TendstoLocallyUniformly F f l →
TendstoLocallyUniformly G g l → TendstoLocallyUniformly (fun i i_1 => F i i_1 - G i i_1... | Eta-expanded form of `TendstoLocallyUniformly.sub` | true |
Fin.lor._proof_1 | Init.Data.Fin.Basic | ∀ {n : ℕ}, ∀ a < n, ∀ (b : ℕ), a.lor b % n < n | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (cond ifTrue ifFalse : Std.Sat.AIG.Fanin),
ifFalse.gate < upper →
∀ (fstate : Std.Sat.AIG.toCNF.State✝ aig),
ifFalse.gate < (Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ fstate)).size | null | false |
StarOrderedRing.mk | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_3} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R],
(∀ (x y : R), x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p) → StarOrderedRing R | null | true |
Real.cos_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x + Real.pi) = -Real.cos x | null | true |
IsBaseChange.linearMapRightBaseChangeEquiv._proof_3 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {R : Type u_5} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Type u_2)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{P : Type u_4} [inst_7 : AddCommMonoid P] [inst_8 : Module R P] [inst_9 : Module S ... | null | false |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Expr.toPolyS.match_4.eq_9 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (k : ℤ) (h_1 : (n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n))
(h_2 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_3 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b))... | null | true |
String.Pos.Splits.cast | Init.Data.String.Lemmas.Splits | ∀ {s₁ s₂ : String} {p : s₁.Pos} {t₁ t₂ : String} (h : s₁ = s₂), p.Splits t₁ t₂ → (p.cast h).Splits t₁ t₂ | null | true |
CategoryTheory.NatTrans.unop_whiskerRight | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor Dᵒᵖ Eᵒᵖ} (α : F ⟶ G),
CategoryTheory.NatTrans.unop (CategoryTheo... | null | true |
intervalIntegral.derivWithin_integral_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
∀ {s t : Set ℝ} [intervalIntegral.FTCFilter b (nhdsWithin b s) (nhdsWithin b t)],
StronglyMeasurableAtFilter f (nhdsWithin b t) MeasureTheory.vol... | Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f x` is continuous
on the right or on the left at `b`, then the right (resp., left) derivative of
`u ↦ ∫ x in a..u, f x` at `b` equals `f b`. | true |
TwoPointing.prop_fst | Mathlib.Basic.TwoPointing | TwoPointing.prop.toProd.1 = False | null | true |
CategoryTheory.Limits.FintypeCat.instPreservesFiniteColimitsFintypeCatForgetFunObjFinite | Mathlib.CategoryTheory.Limits.FintypeCat | CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.forget FintypeCat) | Help typeclass inference to infer preservation of finite colimits for the forgetful functor. | true |
Std.DTreeMap.instCoeTypeForall_2 | Std.Data.DTreeMap.AdditionalOperations | {α : Type u} → Coe (Type v) (α → Type v) | null | true |
PresheafOfModules.Sheafify.SMulCandidate.mk'._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[CategoryTheory.Presheaf.IsLocallyInjective J α] {M₀ : PresheafOfModules R₀}
{A : CategoryTheory.Sheaf J AddCom... | null | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic.0.IntervalIntegrable.comp_mul_left._simp_1_6 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.