name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.HashMap.getKeyD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getKeyD a fallback = fallback | true |
_private.Init.Data.Array.Basic.0.Array.popWhile._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), as.size > 0 → as.size - 1 < as.size | false |
CategoryTheory.IsSifted.of_final_functor_from_sifted | Mathlib.CategoryTheory.Limits.Sifted | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} D]
[h₁ : CategoryTheory.IsSifted C] (F : CategoryTheory.Functor C D) [F.Final], CategoryTheory.IsSifted D | true |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Deriv.0.SchwartzMap.tsupport_derivCLM_subset._simp_1_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, deriv f x = (fderiv 𝕜 f x) 1 | false |
CommApplicative.mk._flat_ctor | Mathlib.Control.Basic | ∀ {m : Type u → Type v} [inst : Applicative m],
(∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β) →
(∀ {α : Type u} (x : m α), id <$> x = x) →
(∀ {α β γ : Type u} (g : α → β) (h : β → γ) (x : m α), (h ∘ g) <$> x = h <$> g <$> x) →
(∀ {α β : Type u} (x : m α) (y : m β), x <* y = Function.const β <$> x <*> y) →
(∀ {α β : Type u} (x : m α) (y : m β), x *> y = Function.const α id <$> x <*> y) →
(∀ {α β : Type u} (g : α → β) (x : m α), pure g <*> x = g <$> x) →
(∀ {α β : Type u} (g : α → β) (x : α), g <$> pure x = pure (g x)) →
(∀ {α β : Type u} (g : m (α → β)) (x : α), g <*> pure x = (fun h => h x) <$> g) →
(∀ {α β γ : Type u} (x : m α) (g : m (α → β)) (h : m (β → γ)),
h <*> (g <*> x) = Function.comp <$> h <*> g <*> x) →
(∀ {α β : Type u} (a : m α) (b : m β), Prod.mk <$> a <*> b = (fun b a => (a, b)) <$> b <*> a) →
CommApplicative m | false |
DerivedCategory.left_fac | Mathlib.Algebra.Homology.DerivedCategory.Fractions | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {X Y : CochainComplex C ℤ} (f : DerivedCategory.Q.obj X ⟶ DerivedCategory.Q.obj Y),
∃ Y' g s,
∃ (x : CategoryTheory.IsIso (DerivedCategory.Q.map s)),
f = CategoryTheory.CategoryStruct.comp (DerivedCategory.Q.map g) (CategoryTheory.inv (DerivedCategory.Q.map s)) | true |
Finset.mk_cons | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a : α} {s : Multiset α} (h : (a ::ₘ s).Nodup),
{ val := a ::ₘ s, nodup := h } = Finset.cons a { val := s, nodup := ⋯ } ⋯ | true |
Std.Packages.LinearOrderOfLEArgs.max_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfLEArgs α),
let this := self.le;
let this_1 := self.decidableLE;
let this_2 := self.max;
∀ (a b : α), a ⊔ b = if b ≤ a then a else b | true |
ContinuousMapZero.instT0Space | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_3} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] [T0Space R], T0Space (ContinuousMapZero X R) | true |
Module.Ray.ind | Mathlib.LinearAlgebra.Ray | ∀ (R : Type u_1) [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {C : Module.Ray R M → Prop},
(∀ (v : M) (hv : v ≠ 0), C (rayOfNeZero R v hv)) → ∀ (x : Module.Ray R M), C x | true |
CliffordAlgebra.contractLeft_one | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (d : Module.Dual R M), (CliffordAlgebra.contractLeft d) 1 = 0 | true |
Order.pred_le_of_wcovBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α}, b ⩿ a → Order.pred a ≤ b | true |
MonoidAlgebra.distribMulActionHom_ext'_iff | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] {N : Type u_5} [inst_1 : Monoid R]
[inst_2 : AddMonoid N] [inst_3 : DistribMulAction R N] [inst_4 : DistribMulAction R k]
{f g : MonoidAlgebra k G →+[R] N},
f = g ↔
∀ (a : G), f.comp (MonoidAlgebra.singleDistribMulActionHom a) = g.comp (MonoidAlgebra.singleDistribMulActionHom a) | true |
CStarMatrix.instInhabited | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} → {n : Type u_2} → {A : Type u_5} → [Inhabited A] → Inhabited (CStarMatrix m n A) | true |
Std.ExtTreeSet.mem_iff_isSome_get? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {a : α},
a ∈ t ↔ (t.get? a).isSome = true | true |
_private.Std.Time.Format.Basic.0.Std.Time.exactly.go._unsafe_rec | Std.Time.Format.Basic | {α : Type} → Std.Internal.Parsec.String.Parser α → ℕ → Array α → ℕ → Std.Internal.Parsec.String.Parser (Array α) | false |
RootPairing.coroot'In | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_4} →
{N : Type u_5} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
(P : RootPairing ι R M N) →
(S : Type u_6) →
[inst_5 : CommRing S] →
[inst_6 : Algebra S R] →
[inst_7 : Module S M] →
[IsScalarTower S R M] →
[FaithfulSMul S R] → [P.IsValuedIn S] → ι → Module.Dual S ↥(P.rootSpan S) | true |
Aesop.Options.traceScript._default | Aesop.Options.Public | Bool | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.succMany?_eq | Init.Data.Range.Polymorphic.SInt | ∀ {n : ℕ} {α : Type u} [Std.PRange.UpwardEnumerable α] [inst : LE α] [inst_1 : LT α] [m : HasModel✝ α (BitVec n)]
{x : α} {k : ℕ},
Std.PRange.succMany? k x =
if (HasModel.encode✝ x).toInt + ↑k ≤ (BitVec.Signed.intMaxSealed✝ n).toInt then
some (HasModel.decode✝ (BitVec.ofInt n ((HasModel.encode✝¹ x).toInt + ↑k)))
else none | true |
Tropical.add_eq_right | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LinearOrder R] ⦃x y : Tropical R⦄, y ≤ x → x + y = y | true |
CompactlySupportedContinuousMap.instNonUnitalCommRingOfIsTopologicalRing._proof_9 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonUnitalCommRing β]
[inst_3 : IsTopologicalRing β] (f g : CompactlySupportedContinuousMap α β), ⇑(f - g) = ⇑f - ⇑g | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.expand.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α] (data_2 : Array (Std.DHashMap.Internal.AssocList α β))
(hd : 0 < data_2.size),
Std.DHashMap.Internal.Raw₀.expand ⟨data_2, hd⟩ =
Std.DHashMap.Internal.Raw₀.expand.go✝ 0 data_2
⟨Array.replicate (data_2.size * 2) Std.DHashMap.Internal.AssocList.nil, ⋯⟩ | true |
Finset.exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to | Mathlib.Combinatorics.Pigeonhole | ∀ {α : Type u} {β : Type v} {M : Type w} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β} {b : M}
[inst_1 : CommSemiring M] [inst_2 : LinearOrder M] [IsStrictOrderedRing M],
(∀ a ∈ s, f a ∈ t) → t.card • b < ↑s.card → ∃ y ∈ t, b < ↑{x ∈ s | f x = y}.card | true |
ValuationRing.instInhabitedValueGroup | Mathlib.RingTheory.Valuation.ValuationRing | (A : Type u) →
[inst : CommRing A] →
(K : Type v) → [inst_1 : Field K] → [inst_2 : Algebra A K] → Inhabited (ValuationRing.ValueGroup A K) | true |
AddCommSemigroup.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) → (∀ (a b c : G), a + b + c = a + (b + c)) → (∀ (a b : G), a + b = b + a) → AddCommSemigroup G | false |
_private.Lean.Expr.0.Lean.mkAndN._sparseCasesOn_1 | Lean.Expr | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
AlgebraicGeometry.Proj.toBasicOpenOfGlobalSections.congr_simp | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {X : AlgebraicGeometry.Scheme} (f f_1 : A →+* ↑(X.presheaf.obj (Opposite.op ⊤)))
(e_f : f = f_1) {x : ↑(X.presheaf.obj (Opposite.op ⊤))} {t : A} {d d_1 : ℕ} (e_d : d = d_1) (H : f t = x)
(h0d : 0 < d) (hd : t ∈ 𝒜 d),
AlgebraicGeometry.Proj.toBasicOpenOfGlobalSections 𝒜 f H h0d hd =
AlgebraicGeometry.Proj.toBasicOpenOfGlobalSections 𝒜 f_1 ⋯ ⋯ ⋯ | true |
instIsEquivalenceUliftFunctorOfUnivLE | Mathlib.CategoryTheory.UnivLE | ∀ [UnivLE.{max u v, v}], CategoryTheory.uliftFunctor.{u, v}.IsEquivalence | true |
instTopologicalSpaceCircle._aux_1 | Mathlib.Analysis.Complex.Circle | Set Circle → Prop | false |
CategoryTheory.MorphismProperty.IsStableUnderBaseChange.op | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderBaseChange], P.op.IsStableUnderCobaseChange | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (lhs rhs : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr)
(lhs_1 rhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core a b lhs rhs =
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core a_1 b_1 lhs_1 rhs_1) =
(a = a_1 ∧ b = b_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1) | true |
AddGrpCat.instFullUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | AddGrpCat.uliftFunctor.Full | true |
finRotate_succ_apply | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ} (i : Fin (n + 1)), (finRotate (n + 1)) i = i + 1 | true |
CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom_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} {A : Type u_4}
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] {G : CategoryTheory.Functor C D} [inst_3 : G.IsCoverDense K]
[inst_4 : G.IsLocallyFull K] {ℱ : CategoryTheory.Functor Dᵒᵖ A} {ℱ' : CategoryTheory.Sheaf K A}
(α : G.op.comp ℱ ⟶ G.op.comp ℱ'.obj) (X : Aᵒᵖ),
(CategoryTheory.Functor.IsCoverDense.sheafCoyonedaHom α).app X =
CategoryTheory.Functor.IsCoverDense.Types.presheafHom
(CategoryTheory.Functor.IsCoverDense.homOver α (Opposite.unop X)) | true |
BoundedAdd.casesOn | Mathlib.Topology.Bornology.BoundedOperation | {R : Type u_1} →
[inst : Bornology R] →
[inst_1 : Add R] →
{motive : BoundedAdd R → Sort u} →
(t : BoundedAdd R) →
((isBounded_add :
∀ {s t : Set R}, Bornology.IsBounded s → Bornology.IsBounded t → Bornology.IsBounded (s + t)) →
motive ⋯) →
motive t | false |
Finset.image₂_subset_iff_left | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f : α → β → γ} {s : Finset α} {t : Finset β}
{u : Finset γ}, Finset.image₂ f s t ⊆ u ↔ ∀ a ∈ s, Finset.image (fun b => f a b) t ⊆ u | true |
LinearMap.IsReflective.isOrthogonal_reflection | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x), B.IsSymm → B.IsOrthogonal ⇑(Module.reflection ⋯) | true |
Mathlib.Notation.«term∃!_,_» | Mathlib.Logic.ExistsUnique | Lean.ParserDescr | true |
Prod.instOmegaCompletePartialOrder | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} → [OmegaCompletePartialOrder α] → [OmegaCompletePartialOrder β] → OmegaCompletePartialOrder (α × β) | true |
SeminormedAddCommGroup.dist._default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → (E → ℝ) → (E → E → E) → (E → E) → E → E → ℝ | false |
Lean.Json.ctorElim | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(ctorIdx : ℕ) → (t : Lean.Json) → ctorIdx = t.ctorIdx → Lean.Json.ctorElimType ctorIdx → motive_1 t | false |
Function.HasFiniteMulSupport | Mathlib.Algebra.FiniteSupport.Defs | {α : Type u_1} → {M : Type u_2} → [One M] → (α → M) → Prop | true |
MulActionHom.mk | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{φ : M → N} →
{X : Type u_5} →
[inst : SMul M X] →
{Y : Type u_6} →
[inst_1 : SMul N Y] → (toFun : X → Y) → (∀ (m : M) (x : X), toFun (m • x) = φ m • toFun x) → X →ₑ[φ] Y | true |
MeasureTheory.Measure.support_add | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] (μ ν : MeasureTheory.Measure X),
(μ + ν).support = μ.support ∪ ν.support | true |
Batteries.DList.singleton_eq_ofThunk | Batteries.Data.DList.Lemmas | ∀ {α : Type u_1} {a : α}, Batteries.DList.singleton a = Batteries.DList.ofThunk { fn := fun x => [a] } | true |
OrthonormalBasis.sum_sq_norm_inner_left | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E) (x : E),
∑ i, ‖inner 𝕜 x (b i)‖ ^ 2 = ‖x‖ ^ 2 | true |
_private.Mathlib.Data.Set.Prod.0.Set.union_pi_inter._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)},
(∀ i ∉ s₁, t₁ i = Set.univ) → (∀ i ∉ s₂, t₂ i = Set.univ) → ((s₁ ∪ s₂).pi fun i => t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂ | false |
Module.Basis.ext_elem_iff | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) {x y : M}, x = y ↔ ∀ (i : ι), (b.repr x) i = (b.repr y) i | true |
Tactic.ComputeAsymptotics.BasisExtension.getBasis._sunfold | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | {basis : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.BasisExtension basis → Tactic.ComputeAsymptotics.Basis | false |
instMonoidWithZeroLex | Mathlib.Algebra.Order.GroupWithZero.Synonym | {α : Type u_1} → [h : MonoidWithZero α] → MonoidWithZero (Lex α) | true |
Filter.frequently_and_distrib_left._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {p : Prop} {q : α → Prop}, (∃ᶠ (x : α) in f, p ∧ q x) = (p ∧ ∃ᶠ (x : α) in f, q x) | false |
Mathlib.Tactic.Order.findContradictionWithNle | Mathlib.Tactic.Order | Mathlib.Tactic.Order.Graph → Array Mathlib.Tactic.Order.AtomicFact → Mathlib.Tactic.AtomM (Option Lean.Expr) | true |
Stream'.Seq.length_take_of_le_length | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ}, (∀ (h : s.Terminates), n ≤ s.length h) → (Stream'.Seq.take n s).length = n | true |
_private.Mathlib.Topology.ContinuousMap.Bounded.Normed.0.BoundedContinuousFunction.norm_add_eq_max._simp_1_2 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | false |
Trans.trans | Init.Prelude | {α : Sort u_1} →
{β : Sort u_2} →
{γ : Sort u_3} →
{r : α → β → Sort u} →
{s : β → γ → Sort v} →
{t : outParam (α → γ → Sort w)} → [self : Trans r s t] → {a : α} → {b : β} → {c : γ} → r a b → s b c → t a c | true |
SkewMonoidAlgebra.instDistribMulAction._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} {S : Type u_3} [inst : Monoid S] [inst_1 : AddMonoid k] [inst_2 : DistribMulAction S k]
(a : S) (b : SkewMonoidAlgebra k G), (a • b).toFinsupp = a • b.toFinsupp | false |
ONote.NFBelow.brecOn | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : (a : ONote) → (a_1 : Ordinal.{0}) → a.NFBelow a_1 → Prop} {a : ONote} {a_1 : Ordinal.{0}}
(t : a.NFBelow a_1),
(∀ (a : ONote) (a_2 : Ordinal.{0}) (t : a.NFBelow a_2), ONote.NFBelow.below t → motive a a_2 t) → motive a a_1 t | true |
Nat.Linear.PolyCnstr.casesOn | Init.Data.Nat.Linear | {motive : Nat.Linear.PolyCnstr → Sort u} →
(t : Nat.Linear.PolyCnstr) →
((eq : Bool) → (lhs rhs : Nat.Linear.Poly) → motive { eq := eq, lhs := lhs, rhs := rhs }) → motive t | false |
HasFDerivWithinAt.add_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (c : F), HasFDerivWithinAt f f' s x → HasFDerivWithinAt (fun x => f x + c) f' s x | true |
CategoryTheory.ObjectProperty.ColimitOfShape.mk._flat_ctor | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} J] →
{X : C} →
(diag : CategoryTheory.Functor J C) →
(ι : diag ⟶ (CategoryTheory.Functor.const J).obj X) →
CategoryTheory.Limits.IsColimit { pt := X, ι := ι } → (∀ (j : J), P (diag.obj j)) → P.ColimitOfShape J X | false |
_private.Mathlib.Topology.DiscreteSubset.0.discreteTopology_subtype_iff._simp_1_2 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) = ∀ (x : ↑s), p ↑x ⋯ | false |
Ring.instFaithfulSMulNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S], FaithfulSMul R (Ring.NormalClosure R S) | true |
List.permutationsAux2.match_3 | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_3} →
(motive : List α → (List α → β) → Sort u_2) →
(x : List α) →
(x_1 : List α → β) →
((x : List α → β) → motive [] x) →
((y : α) → (ys : List α) → (f : List α → β) → motive (y :: ys) f) → motive x x_1 | false |
AddSubgroup.orderIsoAddCon_symm_apply_coe | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (c : AddCon G), ↑((RelIso.symm AddSubgroup.orderIsoAddCon) c) = c.addSubgroup | true |
Finpartition.card_parts_equitabilise | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {m a b : ℕ} (P : Finpartition s)
(h : a * m + b * (m + 1) = s.card), m ≠ 0 → (Finpartition.equitabilise h).parts.card = a + b | true |
Lean.Grind.OrderedRing.toOrderedAdd | Init.Grind.Ordered.Ring | ∀ {R : Type u} {inst : Lean.Grind.Semiring R} {inst_1 : LE R} {inst_2 : LT R} {inst_3 : Std.IsPreorder R}
[self : Lean.Grind.OrderedRing R], Lean.Grind.OrderedAdd R | true |
Lean.Elab.Tactic.BVDecide.Frontend.SolverMode.default.elim | Std.Tactic.BVDecide.Syntax | {motive : Lean.Elab.Tactic.BVDecide.Frontend.SolverMode → Sort u} →
(t : Lean.Elab.Tactic.BVDecide.Frontend.SolverMode) →
t.ctorIdx = 2 → motive Lean.Elab.Tactic.BVDecide.Frontend.SolverMode.default → motive t | false |
_private.Mathlib.Order.SuccPred.Tree.0.RootedTree.mem_subtrees_disjoint_iff._simp_1_2 | Mathlib.Order.SuccPred.Tree | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | false |
Lean.logUnknownDecl | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.Name → m Unit | true |
Lean.expandMacros | Init.Meta.Defs | Lean.Syntax → (optParam (Lean.SyntaxNodeKind → Bool) fun k => k != `Lean.Parser.Term.byTactic) → Lean.MacroM Lean.Syntax | true |
BitVec.shiftConcat.eq_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : BitVec n) (b : Bool), x.shiftConcat b = BitVec.truncate n (x.concat b) | true |
CategoryTheory.MonoidalCategory.tensor_obj | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C × C),
(CategoryTheory.MonoidalCategory.tensor C).obj X = CategoryTheory.MonoidalCategoryStruct.tensorObj X.1 X.2 | true |
Set.image_pow_of_ne_zero | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] [inst_2 : FunLike F α β]
[MulHomClass F α β] {n : ℕ}, n ≠ 0 → ∀ (f : F) (s : Set α), ⇑f '' (s ^ n) = (⇑f '' s) ^ n | true |
ContractibleSpace.hequiv_unit | Mathlib.Topology.Homotopy.Contractible | ∀ (X : Type u_1) [inst : TopologicalSpace X] [ContractibleSpace X], Nonempty (ContinuousMap.HomotopyEquiv X Unit) | true |
innerSLFlip._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 | false |
SubMulAction.fixingSubgroupInsertEquiv._proof_5 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (a : α)
(s : Set ↥(SubMulAction.ofStabilizer M a)) (m : ↥(fixingSubgroup (↥(MulAction.stabilizer M a)) s)),
↑↑m ∈ fixingSubgroup M (insert a (Subtype.val '' s)) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.nonsingular_neg._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [Nontrivial R], W'.Nonsingular ![0, 1, 0] = True | false |
Lean.mkFreshLMVarId | Lean.Expr | {m : Type → Type} → [Monad m] → [Lean.MonadNameGenerator m] → m Lean.LMVarId | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.arg_mul_cos_add_sin_mul_I._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (a b : ℝ), ↑a + ↑b * Complex.I = { re := a, im := b } | false |
CategoryTheory.Limits.BiconeMorphism.wι_assoc | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {A B : CategoryTheory.Limits.Bicone F}
(self : CategoryTheory.Limits.BiconeMorphism A B) (j : J) {Z : C} (h : B.pt ⟶ Z),
CategoryTheory.CategoryStruct.comp (A.ι j) (CategoryTheory.CategoryStruct.comp self.hom h) =
CategoryTheory.CategoryStruct.comp (B.ι j) h | true |
_private.Lean.Data.Trie.0.Lean.Data.Trie.upsert.insertEmpty._unsafe_rec | Lean.Data.Trie | {α : Type} → String → (Option α → α) → ℕ → Lean.Data.Trie α | false |
AddMonoidHom.addSubmonoidComap.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (N' : AddSubmonoid N),
f.addSubmonoidComap N' = { toFun := fun x => ⟨f ↑x, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ } | true |
Lean.Lsp.WorkDoneProgressOptions | Lean.Data.Lsp.Basic | Type | true |
Complex.one_re | Mathlib.Data.Complex.Basic | Complex.re 1 = 1 | true |
StandardEtalePair.inv_aeval_X_g | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
↑⋯.unit⁻¹ = (Ideal.Quotient.mk (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})) Polynomial.X | true |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Poly.denoteS.match_1.eq_2 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Poly → Sort u_1) (k : ℤ) (m : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k))
(h_2 :
(k : ℤ) →
(m : Lean.Grind.CommRing.Mon) → (p : Lean.Grind.CommRing.Poly) → motive (Lean.Grind.CommRing.Poly.add k m p)),
(match Lean.Grind.CommRing.Poly.add k m p with
| Lean.Grind.CommRing.Poly.num k => h_1 k
| Lean.Grind.CommRing.Poly.add k m p => h_2 k m p) =
h_2 k m p | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.jp | Lean.Compiler.LCNF.InferBorrow | Lean.Name → Lean.FVarId → Lean.Compiler.LCNF.ParamMap.Key✝ | true |
Std.LawfulOrderBEq.mk | Init.Data.Order.Classes | ∀ {α : Type u} [inst : BEq α] [inst_1 : LE α], (∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a) → Std.LawfulOrderBEq α | true |
XorOp.xor | Init.Prelude | {α : Type u} → [self : XorOp α] → α → α → α | true |
Lean.Elab.Tactic.mkInitialTacticInfo | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM (Lean.Elab.Tactic.TacticM Lean.Elab.Info) | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceSucc.declare_36._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.803612042._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | false |
dite_prop_iff_and | Mathlib.Logic.Basic | ∀ {P : Prop} [inst : Decidable P] {Q : P → Prop} {R : ¬P → Prop}, dite P Q R ↔ (∀ (h : P), Q h) ∧ ∀ (h : ¬P), R h | true |
IsLowerSet.thickening' | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {α : Type u_1} [inst : NormedCommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α] {s : Set α},
IsLowerSet s → ∀ (ε : ℝ), IsLowerSet (Metric.thickening ε s) | true |
HahnSeries.cardSuppLTSubring._proof_2 | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ (Γ : Type u_1) (R : Type u_2) (κ : Cardinal.{u_1}) [inst : PartialOrder Γ] [inst_1 : AddCommMonoid Γ]
[inst_2 : Ring R] [hκ : Fact (Cardinal.aleph0 ≤ κ)], HahnSeries.cardSupp 1 < κ | false |
CommMagma.rec | Mathlib.Algebra.Group.Defs | {G : Type u} →
{motive : CommMagma G → Sort u_1} →
([toMul : Mul G] → (mul_comm : ∀ (a b : G), a * b = b * a) → motive { toMul := toMul, mul_comm := mul_comm }) →
(t : CommMagma G) → motive t | false |
continuous_max | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderClosedTopology α],
Continuous fun p => max p.1 p.2 | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical.bvExpr | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical → Std.Tactic.BVDecide.BVLogicalExpr | true |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.instLawfulUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | ∀ {α : Type u} [inst : LE α] [inst_1 : LT α] {β : Type v} [inst_2 : LE β] [inst_3 : LT β]
[inst_4 : Std.PRange.UpwardEnumerable β] [inst_5 : Std.PRange.LawfulUpwardEnumerable β]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLE β] [inst_7 : Std.PRange.LawfulUpwardEnumerableLT β] [m : HasModel✝ α β],
Std.PRange.LawfulUpwardEnumerable α | true |
Lean.Grind.CommRing.Poly.divConst._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → ℤ → Lean.Grind.CommRing.Poly | false |
Int.eq_one_of_mul_eq_self_left | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, a ≠ 0 → b * a = a → b = 1 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.