name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WType._sizeOf_1 | Mathlib.Data.W.Basic | {α : Type u_1} → {β : α → Type u_2} → [SizeOf α] → [(a : α) → SizeOf (β a)] → WType β → ℕ | null | false |
Submodule.IsAssociatedPrime.recOn | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Submodule R M} →
{I : Ideal R} →
{motive : N.IsAssociatedPrime I → Sort u} →
(t : N.IsAssociatedPrime I) →
((toI... | null | false |
Std.instDecidableEqRci | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → DecidableEq (Std.Rci α) | null | true |
FourierInvModule._sizeOf_inst | Mathlib.Analysis.Fourier.Notation | (R : Type u_5) →
(E : Type u_6) →
(F : outParam (Type u_7)) →
{inst : Add E} →
{inst_1 : Add F} →
{inst_2 : SMul R E} →
{inst_3 : SMul R F} → [SizeOf R] → [SizeOf E] → [SizeOf F] → SizeOf (FourierInvModule R E F) | null | false |
Function.LeftInverse.rightInverse_of_surjective | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α},
Function.LeftInverse f g → Function.Surjective g → Function.RightInverse f g | null | true |
CochainComplex.HomComplex.Cocycle.equivHom_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(F G : CochainComplex C ℤ) (φ : F ⟶ G),
(CochainComplex.HomComplex.Cocycle.equivHom F G) φ = CochainComplex.HomComplex.Cocycle.ofHom φ | null | true |
Lean.Parser.Term.doSeqItem | Lean.Parser.Do | Lean.Parser.Parser | null | true |
_private.Lean.PrivateName.0.Lean.privatePrefixAux._unsafe_rec | Lean.PrivateName | Lean.Name → Lean.Name | null | false |
Valuation.instLinearOrderedCommGroupWithZeroMrange._aux_10 | Mathlib.RingTheory.Valuation.Archimedean | {F : Type u_2} →
{Γ₀ : Type u_1} →
[inst : Field F] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation F Γ₀} → ↥(MonoidHom.mrange v) → ↥(MonoidHom.mrange v) | null | false |
_private.Lean.Meta.Tactic.Grind.Proof.0.Lean.Meta.Grind.mkHCongrProof'._unsafe_rec | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Expr → Bool → Lean.Meta.Grind.GoalM Lean.Expr | null | false |
BooleanSubalgebra.map._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_1} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (f : BoundedLatticeHom α β)
(L : BooleanSubalgebra α), SupClosed (⇑f '' ↑L) | null | false |
real_inner_I_smul_self | Mathlib.Analysis.InnerProductSpace.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x : E), inner ℝ x (RCLike.I • x) = 0 | null | true |
Lean.Meta.DSimp.ConfigWithOptions._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Meta.DSimp.ConfigWithOptions → ℕ | null | false |
CategoryTheory.sectionsFunctorNatIsoCoyoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(X : Type (max u₁ u₂)) →
[Unique X] →
CategoryTheory.Functor.sectionsFunctor C ≅
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X)) | A natural isomorphism between the sections functor `(C ⥤ Type) ⥤ Type` and the co-Yoneda
embedding of a terminal functor, specifically a constant functor on a given singleton type `X`. | true |
WithOne | Mathlib.Algebra.Group.WithOne.Defs | Type u_1 → Type u_1 | Add an extra element `1` to a type | true |
AddOpposite.unop_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : αᵃᵒᵖ),
AddOpposite.unop (x - y) = -AddOpposite.unop y + AddOpposite.unop x | null | true |
Representation.free | Mathlib.RepresentationTheory.Basic | (k : Type u_6) →
(G : Type u_7) → [inst : CommSemiring k] → [inst_1 : Monoid G] → (α : Type u_8) → Representation k G (α →₀ G →₀ k) | The representation on `α →₀ k[G]` defined pointwise by the left regular representation. | true |
Std.ExtHashMap.get?.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β), m = m_1 → ∀ (a a_1 : α), a = a_1 → m.get? a = m_1.get? a_1 | null | true |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_6 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (f : CategoryTheory.Arrow (Type u_1)),
CategoryTheory.MorphismProperty.surjective (Type u_1)
({ app := fun f => TypeCat.ofHom fun x => ⟨(CategoryTheory.ConcreteCategory.hom f.hom) x, ⋯⟩, naturality := ⋯ }.app
f) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {i : ℕ}, i ≠ 0 → i - 1 + 1 = i | null | false |
Lean.Parser.Tactic.Grind.mbtc | Init.Grind.Interactive | Lean.ParserDescr | Adds new case-splits using model-based theory combination.
| true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.mkExprMatcher.match_1 | Mathlib.Util.Notation3 | (motive : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name → Sort u_1) →
(__discr : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name) →
((lctx : Lean.LocalContext) → (boundFVars : Std.HashMap Lean.FVarId Lean.Name) → motive (lctx, boundFVars)) →
motive __discr | null | false |
Primrec.subtype_val_iff | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop}
[inst_2 : DecidablePred p] {hp : PrimrecPred p} {f : α → Subtype p}, (Primrec fun a => ↑(f a)) ↔ Primrec f | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.normNatAddInst.declare_33._@.Lean.Meta.Tactic.Grind.Arith.Simproc.114900174._hygCtx._hyg.16 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit | null | false |
Lean.Grind.CommRing.Poly.mulMonC.go | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Mon → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | true |
IndiscreteTopology.eq_top_iff_indiscrete | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} [u : UniformSpace α], u = ⊤ ↔ IndiscreteTopology α | null | true |
LocalizedModule.instSemiring._proof_5 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Submonoid R}
(a b c : LocalizedModule S A), (a + b) * c = a * c + b * c | null | false |
Equiv.simpleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (e : V ≃ W) (x : SimpleGraph V),
SimpleGraph.comap (⇑e) (SimpleGraph.comap (⇑e.symm) x) = x | null | false |
Path.Homotopy.hcomp._proof_8 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ : X} {p₀ q₀ : Path x₀ x₁} {p₁ q₁ : Path x₁ x₂}
(F : p₀.Homotopy q₀) (G : p₁.Homotopy q₁),
Continuous fun x => if ↑x.2 ≤ 1 / 2 then (F.eval x.1).extend (2 * ↑x.2) else (G.eval x.1).extend (2 * ↑x.2 - 1) | null | false |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_mem_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a (Std.DHashMap.Raw.Const.get m a h) = false) | null | true |
Lean.Elab.Tactic.ElimApp.Result.motive | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Result → Lean.MVarId | null | true |
ModularForm.coe_eq_zero_iff._simp_1 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f : ModularForm Γ k), (⇑f = 0) = (f = 0) | null | false |
VectorPrebundle.continuousOn_coordChange | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : (x : B) → TopologicalSpace (E x)]
(a ... | null | true |
_private.Mathlib.Topology.Algebra.Module.Spaces.WeakBilin.0.WeakBilin.instIsScalarTower._proof_1 | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | ∀ {𝕜 : Type u_2} {𝕝 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : CommSemiring 𝕝]
[inst_2 : AddCommMonoid E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F] [inst_6 : SMul 𝕝 𝕜]
[inst_7 : Module 𝕝 E] [IsScalarTower 𝕝 𝕜 E] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜), IsS... | null | false |
Finset.univ_nontrivial_iff | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.Nontrivial ↔ Nontrivial α | null | true |
tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s ↔ TendstoLocallyUniformly (fun i x => F i ↑x) (f ∘ Subtype.val) p | null | true |
CategoryTheory.Functor.IsCoverDense.Types.presheafHom_app | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.Sheaf K (Type v)}
[inst_2 : G.IsCoverDense K] [i... | null | true |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.varFinsetLeft.match_1.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_4} {β : Type u_3} (motive : L.Term (α ⊕ β) → Sort u_5) (_i : β)
(h_1 : (i : α) → motive (FirstOrder.Language.var (Sum.inl i)))
(h_2 : (_i : β) → motive (FirstOrder.Language.var (Sum.inr _i)))
(h_3 : (l : ℕ) → (_f : L.Functions l) → (ts : Fin l → L.Term (α ⊕ β)) → motive (Fi... | null | true |
Submodule.subtypeₗᵢ_toContinuousLinearMap | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {R' : Type u_11} [inst_1 : Ring R'] [inst_2 : Module R' E]
(p : Submodule R' E), p.subtypeₗᵢ.toContinuousLinearMap = p.subtypeL | null | true |
CategoryTheory.MorphismProperty.pullback_snd_iff | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.IsStableUnderBaseChange] [P.DescendsAlong Q]
[inst_3 : CategoryTheory.Limits.HasPullback f g], Q g → (P (CategoryTheory.Limits.pullback.snd f g) ↔ P f) | null | true |
Differential.logDeriv.eq_1 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : Field R] [inst_1 : Differential R] (a : R), Differential.logDeriv a = a′ / a | null | true |
Array.toList_mapFinIdxM | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
{f : (i : ℕ) → α → i < xs.size → m β}, Array.toList <$> xs.mapFinIdxM f = xs.toList.mapFinIdxM f | null | true |
Polynomial.sylveserMap_comp_adjSylvester | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
f.sylvesterMap g hf hg ∘ₗ f.adjSylvester g = f.resultant g m n • LinearMap.id | null | true |
Polynomial.mahlerMeasure_const | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (z : ℂ), (Polynomial.C z).mahlerMeasure = ‖z‖ | null | true |
Std.TreeMap.getKey?_map | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, (Std.TreeMap.map f t).getKey? k = t.getKey? k | null | true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.tensorHom_comp_tensorHom | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X₁ Y₁ Z₁ X₂ Y₂ Z₂ : CategoryTheory.FreeMonoidalCategory C} (f₁ : X₁.Hom Y₁) (f₂ : X₂.Hom Y₂) (g₁ : Y₁.Hom Z₁)
(g₂ : Y₂.Hom Z₂), CategoryTheory.FreeMono... | null | true |
_private.Mathlib.Data.Vector3.0.Fin2.insertPerm.match_1.eq_3 | Mathlib.Data.Vector3 | ∀ (motive : (x : ℕ) → Fin2 x → Fin2 x → Sort u_1) (a : ℕ) (a_1 : Fin2 a.succ)
(h_1 : (n : ℕ) → motive (n + 1) Fin2.fz Fin2.fz) (h_2 : (n : ℕ) → (j : Fin2 n) → motive (n + 1) Fin2.fz j.fs)
(h_3 : (a : ℕ) → (a_2 : Fin2 a.succ) → motive (a.succ + 1) a_2.fs Fin2.fz)
(h_4 : (a : ℕ) → (i : Fin2 a.succ) → (j : Fin2 (a +... | null | true |
CategoryTheory.RingObjCat.Hom.mk.inj | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.CartesianMonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} {R₁ R₂ : CategoryTheory.RingObjCat C} {hom : R₁.X ⟶ R₂.X}
{isRingHom : CategoryTheory.IsRingHom hom} {hom_1 : R₁.X ⟶ R₂.X} {isRingHom_1 : CategoryTheory.IsRingHo... | null | true |
IsCompact.exists_isGLB | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [ClosedIicTopology α] {s : Set α},
IsCompact s → s.Nonempty → ∃ x ∈ s, IsGLB s x | null | true |
_private.Init.Data.Nat.Basic.0.Nat.exists_eq_succ_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
Lean.Meta.Grind.Arith.propagateNatXOr | Lean.Meta.Tactic.Grind.Arith.Propagate | Lean.Meta.Grind.Propagator | null | true |
Subring.mk.injEq | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (toSubsemiring : Subsemiring R)
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) (toSubsemiring_1 : Subsemiring R)
(neg_mem'_1 : ∀ {x : R}, x ∈ toSubsemiring_1.carrier → -x ∈ toSubsemiring_1.carrier),
({ toSubsemiring := toSubsemiring, neg_mem' ... | null | true |
Lean.Meta.AuxLemmas.mk.sizeOf_spec | Lean.Meta.Tactic.AuxLemma | ∀ (lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name × List Lean.Name)),
sizeOf { lemmas := lemmas } = 1 + sizeOf lemmas | null | true |
Lean.PrettyPrinter.Delaborator.delabSort | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | null | true |
HahnSeries.SummableFamily.instAddCommGroup._proof_7 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} {α : Type u_2} [inst : PartialOrder Γ] [inst_1 : AddCommGroup R] (a : ℤ)
(a_1 : HahnSeries.SummableFamily Γ R α), (⋃ a_2, ((a • ⇑a_1) a_2).support).IsPWO | null | false |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} → S₁.Hom S₂ → S₂.Hom S₃ → S₁.Hom S₃ | The composition of morphisms of snake inputs. | true |
CategoryTheory.ReflPrefunctor.«_aux_Mathlib_Combinatorics_Quiver_ReflQuiver___macroRules_CategoryTheory_ReflPrefunctor_term_⥤rq__1» | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.Macro | null | false |
Nat.Pseudoperfect.eq_1 | Mathlib.NumberTheory.FactorisationProperties | ∀ (n : ℕ), n.Pseudoperfect = (0 < n ∧ ∃ s ⊆ n.properDivisors, ∑ i ∈ s, i = n) | null | true |
AddLocalization.decidableEq.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : IsCancelAdd α] {s : AddSubmonoid α} [inst_2 : DecidableEq α]
(a b : AddLocalization s),
a.decidableEq b = a.recOnSubsingleton₂ b fun x x_1 x_2 x_3 => decidable_of_iff' (↑x_3 + x = ↑x_2 + x_1) ⋯ | null | true |
Filter.eventually_and | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x | null | true |
Set.range_inl | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2}, Set.range Sum.inl = {x | x.isLeft = true} | null | true |
_private.Mathlib.Algebra.Ring.IsFormallyReal.0.IsFormallyReal.instIsReduced._proof_1 | Mathlib.Algebra.Ring.IsFormallyReal | 1 < 2 | null | false |
NonUnitalSubsemiring.comap | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
{F : Type u_1} →
[inst_2 : FunLike F R S] → [NonUnitalRingHomClass F R S] → F → NonUnitalSubsemiring S → NonUnitalSubsemiring R | The preimage of a non-unital subsemiring along a non-unital ring homomorphism is a
non-unital subsemiring. | true |
FirstOrder.Language.graphRel.noConfusion | Mathlib.ModelTheory.Graph | {P : Sort u} →
{a : ℕ} →
{t : FirstOrder.Language.graphRel a} →
{a' : ℕ} →
{t' : FirstOrder.Language.graphRel a'} → a = a' → t ≍ t' → FirstOrder.Language.graphRel.noConfusionType P t t' | null | false |
smul_apply | Mathlib.Data.FunLike.IsApply | ∀ {M : Type u_1} {F : Type u_2} {α : outParam (Type u_3)} {β : outParam (Type u_4)} {inst : FunLike F α β}
{inst_1 : SMul M β} {inst_2 : SMul M F} [self : IsSMulApply M F α β] (f : F) (r : M) (x : α), (r • f) x = r • f x | **Alias** of `IsSMulApply.smul_apply`. | true |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.ArgInfo.rec | Lean.Meta.Tactic.Grind.MBTC | {motive : Lean.Meta.Grind.ArgInfo✝ → Sort u} →
((arg app : Lean.Expr) → motive { arg := arg, app := app }) → (t : Lean.Meta.Grind.ArgInfo✝) → motive t | null | false |
PFunctor.M.casesOn_mk' | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {r : F.M → Sort u_2} {a : F.A} (x : F.B a → F.M)
(f : (a : F.A) → (f : F.B a → F.M) → r (PFunctor.M.mk ⟨a, f⟩)), (PFunctor.M.mk ⟨a, x⟩).casesOn' f = f a x | null | true |
Finset.smul_sum | Mathlib.Algebra.BigOperators.GroupWithZero.Action | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, r • ∑ x ∈ s, f x = ∑ x ∈ s, r • f x | null | true |
OrderMonoidIso.val_inv_unitsWithZero_symm_apply | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_6} [inst : Group α] [inst_1 : Preorder α] (a : α), ↑(OrderMonoidIso.unitsWithZero.symm a)⁻¹ = (↑a)⁻¹ | null | true |
ContMDiffOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[ins... | Consider `C^n` maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a base map
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is `C^n`.
We give here a version of this statement on a set. | true |
Std.Do.PostShape.noConfusion | Std.Do.PostCond | {P : Sort u_1} → {t t' : Std.Do.PostShape} → t = t' → Std.Do.PostShape.noConfusionType P t t' | null | false |
Subfield._sizeOf_inst | Mathlib.Algebra.Field.Subfield.Defs | (K : Type u) → {inst : DivisionRing K} → [SizeOf K] → SizeOf (Subfield K) | null | false |
_private.Mathlib.Topology.Algebra.WithZeroTopology.0.WithZeroTopology.orderClosedTopology._simp_2 | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
ContDiffAt.smulRight | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {n : WithTop ℕ∞} {f : E → Str... | null | true |
Equiv.image_swap_of_mem_of_notMem | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} [inst : DecidableEq α] {s : Set α} {i j : α}, i ∈ s → j ∉ s → ⇑(Equiv.swap i j) '' s = insert j s \ {i} | null | true |
CategoryTheory.Limits.BinaryCofan.isColimitMk._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y W : C} {inl : X ⟶ W} {inr : Y ⟶ W}
(desc : (s : CategoryTheory.Limits.BinaryCofan X Y) → W ⟶ s.pt),
(∀ (s : CategoryTheory.Limits.BinaryCofan X Y) (m : W ⟶ s.pt),
CategoryTheory.CategoryStruct.comp inl m = s.inl →
CategoryTheory.Categ... | null | false |
Finsupp.lsingle_range_le_ker_lapply | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s t : Set α), Disjoint s t → ⨆ a ∈ s, (Finsupp.lsingle a).range ≤ ⨅ a ∈ t, (Finsupp.lapply a).ker | null | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f), CategoryTheory.CategoryStruct.comp (ht.lift s.flip) t.snd = s.fst | null | false |
CategoryTheory.ShortComplex.homMk_τ₁ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂) (τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ : CategoryTheory.CategoryStruct.comp τ₁ S₂.f = CategoryTheory.CategoryStruct.comp S₁.f τ₂)... | null | true |
Matroid.IsCircuit.eq_fundCircuit_of_subset | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C I : Set α} {e : α},
M.IsCircuit C → M.Indep I → C ⊆ insert e I → C = M.fundCircuit e I | For `I` independent, `M.fundCircuit e I` is the only circuit contained in `insert e I`. | true |
LieDerivation.exp_map_apply | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieAlgebra ℚ L] (D : LieDerivation R L L) (h : IsNilpotent ↑D) (l : L), (D.exp h) l = (IsNilpotent.exp ↑D) l | null | true |
Finset.image_comp_eq | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {f : α → β} [inst_1 : DecidableEq γ] {g : β → γ},
Finset.image (g ∘ f) = Finset.image g ∘ Finset.image f | null | true |
Lean.Elab.Structural.EqnInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → ℕ | null | false |
Lean.PrettyPrinter.Parenthesizer.checkColGt.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | null | true |
rootsOfUnityUnitsMulEquiv._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) (ζ ζ' : ↥(rootsOfUnity n Mˣ)), ⟨↑↑(ζ * ζ'), ⋯⟩ = ⟨↑↑ζ, ⋯⟩ * ⟨↑↑ζ', ⋯⟩ | null | false |
WithLp.toLp_fst | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} (x : α × β), (WithLp.toLp p x).fst = x.1 | null | true |
Fintype.prod_eq_mul | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Fintype α] [inst_1 : CommMonoid M] {f : α → M} (a b : α),
a ≠ b → (∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1) → ∏ x, f x = f a * f b | null | true |
Std.IterM.Equiv.of_morphism | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : LawfulMonad m] {β : Type w}
[inst_2 : Std.Iterator α₁ m β] [inst_3 : Std.Iterator α₂ m β] (ita : Std.IterM m β)
(f : Std.IterM m β → Std.IterM m β),
(∀ (it : Std.IterM m β), (f it).stepAsHetT = Std.IterStep.mapIterator f <$> it.stepAsHetT) → ita... | null | true |
_private.Lean.Meta.MethodSpecs.0.Lean.rewriteThm | Lean.Meta.MethodSpecs | Lean.Meta.Simp.Context → Lean.Meta.Simprocs → Lean.Name → Lean.Name → Lean.MetaM Unit | null | true |
geom_sum_Ico_mul_neg | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) {m n : ℕ}, m ≤ n → (∑ i ∈ Finset.Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n | null | true |
Nat.reducePow | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | null | true |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.Φ_coeff_generatorIndex_ne_zero | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)} (h : E ≠ ⊥),
(RatFunc.Luroth.Φ✝ E).coeff (RatFunc.Luroth.generatorIndex✝ h) ≠ 0 | null | true |
MonadReaderOf.read | Init.Prelude | {ρ : semiOutParam (Type u)} → {m : Type u → Type v} → [self : MonadReaderOf ρ m] → m ρ | Retrieves the local value. | true |
Ideal.Pure.eq_1 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), I.Pure = Module.Flat R (R ⧸ I) | null | true |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_naturality_assoc | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | null | true |
Asymptotics.transIsEquivalentIsLittleO | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | {α : Type u_1} →
{β : Type u_2} →
{β₂ : Type u_3} →
[inst : NormedAddCommGroup β] →
[inst_1 : Norm β₂] →
{l : Filter α} → Trans (Asymptotics.IsEquivalent l) (Asymptotics.IsLittleO l) (Asymptotics.IsLittleO l) | null | true |
CategoryTheory.PreOneHypercover.cylinder_X | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (i : E.I₀) × F.I₁ (f.s₀ i) (g.s₀ i)),
(CategoryTheory.PreOneHypercover.cylinder f g).X p = CategoryT... | null | true |
CategoryTheory.CostructuredArrow.ιCompGrothendieckPrecompFunctorToCommaCompFst_hom_app | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | ∀ {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] (L : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor E D) (X : E) (X_1 : ↑((R.comp (CategoryTheory.CostructuredArrow.functor L))... | null | true |
Multiset.mem_filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β},
b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b | null | true |
Algebra.RingHom.adjoinAlgebraMapEquiv._proof_1 | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B)
(p : Polynomial A), (Polynomial.aeval b) p ∈ A[b] | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.