name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Const.get?_filter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
Std.DTreeMap.Const.get? (Std.DTreeMap.filter f t) k =
(Std.DTreeMap.Const.get? t k).pfilter fun x h' => f (t.getKey k ⋯) x | true |
MeasureTheory.MeasureSpace.noConfusionType | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | Sort u → {α : Type u_6} → MeasureTheory.MeasureSpace α → {α' : Type u_6} → MeasureTheory.MeasureSpace α' → Sort u | false |
CategoryTheory.FreeBicategory.bicategory._proof_9 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] (x x_1 x_2 x_3 : CategoryTheory.FreeBicategory B) (f : x ⟶ x_1) (g : x_1 ⟶ x_2)
(h : x_2 ⟶ x_3),
Quot.mk CategoryTheory.FreeBicategory.Rel
((CategoryTheory.FreeBicategory.Hom₂.associator f g h).vcomp
(CategoryTheory.FreeBicategory.Hom₂.associator_inv f g h)) =
Quot.mk CategoryTheory.FreeBicategory.Rel
(CategoryTheory.FreeBicategory.Hom₂.id
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h)) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.check.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Search | (motive : Option Bool → Sort u_1) → (x : Option Bool) → (Unit → motive none) → ((a : Bool) → motive (some a)) → motive x | false |
QuadraticForm.tensorRId_toLinearEquiv | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁), Q₁.tensorRId.toLinearEquiv = TensorProduct.rid R M₁ | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SharedCoefficients | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Type | true |
InnerProductSpace.inner_gramSchmidtOrthonormalBasis_eq_zero | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : WellFoundedLT ι]
[inst_6 : Fintype ι] [inst_7 : FiniteDimensional 𝕜 E] (h : Module.finrank 𝕜 E = Fintype.card ι) {f : ι → E} {i : ι},
InnerProductSpace.gramSchmidtNormed 𝕜 f i = 0 →
∀ (j : ι), inner 𝕜 ((InnerProductSpace.gramSchmidtOrthonormalBasis h f) i) (f j) = 0 | true |
Lean.Meta.ApplyConfig.newGoals | Init.Meta.Defs | Lean.Meta.ApplyConfig → Lean.Meta.ApplyNewGoals | true |
_private.Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero.0.Submonoid.LocalizationMap.noZeroDivisors.match_1_1 | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (n : N) (motive : (∃ x, n * f ↑x.2 = f x.1) → Prop) (x : ∃ x, n * f ↑x.2 = f x.1),
(∀ (ms : M × ↥S) (eq : n * f ↑ms.2 = f ms.1), motive ⋯) → motive x | false |
CancelCommMonoid | Mathlib.Algebra.Group.Defs | Type u → Type u | true |
ConjAct.unitsMulSemiringAction._proof_2 | Mathlib.Algebra.Ring.Action.ConjAct | ∀ {R : Type u_1} [inst : Semiring R] (a : ConjAct Rˣ) (x y : R), a • (x + y) = a • x + a • y | false |
CategoryTheory.Triangulated.Octahedron'.triangleMorphism₂_hom₃ | 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 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃} {u₁₃ : X₁ ⟶ X₃}
(comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃) {v₁₂ : Z₁₂ ⟶ X₁}
{w₁₂ : X₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₁₂}
(h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk v₁₂ u₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
{v₂₃ : Z₂₃ ⟶ X₂} {w₂₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₂₃}
(h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk v₂₃ u₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
{v₁₃ : Z₁₃ ⟶ X₁} {w₁₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj Z₁₃}
(h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk v₁₃ u₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
(h : CategoryTheory.Triangulated.Octahedron' comm h₁₂ h₂₃ h₁₃),
(CategoryTheory.Triangulated.Octahedron'.triangleMorphism₂ comm h₁₂ h₂₃ h₁₃ h).hom₃ =
CategoryTheory.CategoryStruct.id X₃ | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_of_one_to_two.match_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin ((SimplexCategory.mk 1).len + 1) → Prop) (i : Fin ((SimplexCategory.mk 1).len + 1)),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i | false |
TopologicalSpace.CompactOpens.mk.inj | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_4} {inst : TopologicalSpace α} {toCompacts : TopologicalSpace.Compacts α}
{isOpen' : IsOpen toCompacts.carrier} {toCompacts_1 : TopologicalSpace.Compacts α}
{isOpen'_1 : IsOpen toCompacts_1.carrier},
{ toCompacts := toCompacts, isOpen' := isOpen' } = { toCompacts := toCompacts_1, isOpen' := isOpen'_1 } →
toCompacts = toCompacts_1 | true |
«term_→ₙ*_» | Mathlib.Algebra.Group.Hom.Defs | Lean.TrailingParserDescr | true |
_private.Mathlib.Analysis.Complex.Basic.0.RCLike._aux_Mathlib_Analysis_Complex_Basic___macroRules__private_Mathlib_Analysis_Complex_Basic_0_RCLike_termIC_1 | Mathlib.Analysis.Complex.Basic | Lean.Macro | false |
DirectSum.map_id | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → AddCommMonoid (α i)],
(DirectSum.map fun i => AddMonoidHom.id (α i)) = AddMonoidHom.id (DirectSum ι fun i => α i) | true |
Lean.Meta.DefaultInstances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.DefaultInstances → ℕ | false |
commAlgCatEquivUnder_unitIso | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ (R : CommRingCat),
(commAlgCatEquivUnder R).unitIso =
CategoryTheory.NatIso.ofComponents
(fun A =>
CommAlgCat.isoMk
(let __RingEquiv := RingEquiv.refl ↑A;
{ toEquiv := __RingEquiv.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }))
⋯ | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk.inj | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{toLaxFunctor : CategoryTheory.LaxFunctor B C}
{map_id :
autoParam
(∀ (X : B),
toLaxFunctor.map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (toLaxFunctor.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam}
{mapId_eq_eqToHom :
autoParam (∀ (X : B), toLaxFunctor.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam}
{toLaxFunctor_1 : CategoryTheory.LaxFunctor B C}
{map_id_1 :
autoParam
(∀ (X : B),
toLaxFunctor_1.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toLaxFunctor_1.obj X))
CategoryTheory.StrictlyUnitaryLaxFunctor.map_id._autoParam}
{mapId_eq_eqToHom_1 :
autoParam (∀ (X : B), toLaxFunctor_1.mapId X = CategoryTheory.eqToHom ⋯)
CategoryTheory.StrictlyUnitaryLaxFunctor.mapId_eq_eqToHom._autoParam},
{ toLaxFunctor := toLaxFunctor, map_id := map_id, mapId_eq_eqToHom := mapId_eq_eqToHom } =
{ toLaxFunctor := toLaxFunctor_1, map_id := map_id_1, mapId_eq_eqToHom := mapId_eq_eqToHom_1 } →
toLaxFunctor = toLaxFunctor_1 | true |
BitVec.reduceRotateRight._regBuiltin.BitVec.reduceRotateRight.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.3861451550._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
Matroid.IsBasis.isBasis_of_isBasis_of_subset_of_subset | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X Y J : Set α}, M.IsBasis I X → M.IsBasis J Y → J ⊆ X → I ⊆ Y → M.IsBasis I Y | true |
not_isAddTorsionFree_of_isTorsion | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommGroup G] [Nontrivial G], AddMonoid.IsTorsion G → ¬IsAddTorsionFree G | true |
_private.Mathlib.Analysis.Calculus.TangentCone.ProperSpace.0.tangentConeAt_nonempty_of_properSpace._simp_1_4 | Mathlib.Analysis.Calculus.TangentCone.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | false |
AlgebraicGeometry.PresheafedSpace.map_id_c_app._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C))
(j : J), CategoryTheory.CategoryStruct.id ↑(F.obj j) = (F.map (CategoryTheory.CategoryStruct.id j)).base | false |
IntermediateField.isPurelyInseparable_tower_bot | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) [inst : Field F] (K : Type w) [inst_1 : Field K] [inst_2 : Algebra F K] (M : IntermediateField F K)
[IsPurelyInseparable F K], IsPurelyInseparable F ↥M | true |
circleIntegrable_posLog_norm_meromorphicOn_of_nonneg | Mathlib.Analysis.SpecialFunctions.Integrability.LogMeromorphic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {c : ℂ} {R : ℝ} {f : ℂ → E},
MeromorphicOn f (Metric.sphere c R) → 0 ≤ R → CircleIntegrable (fun x => ‖f x‖.posLog) c R | true |
Mathlib.Tactic.Ring.ExBase.evalPos | Mathlib.Tactic.Ring.Common | {a : Q(ℕ)} → Mathlib.Tactic.Ring.ExBase Mathlib.Tactic.Ring.sℕ a → Option Q(0 < «$a») | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_eq_iff_getKey?_eq_self_and_forall._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyS | Mathlib.Tactic.FBinop | FBinopElab.SRec → Lean.Expr → Lean.Elab.TermElabM (Option Lean.Expr) | true |
_private.Lean.Compiler.InitAttr.0.Lean.runInitAttrs.match_3 | Lean.Compiler.InitAttr | (motive : Option (ℕ × Std.Iter ℕ) → Sort u_1) →
(x : Option (ℕ × Std.Iter ℕ)) →
(Unit → motive none) → ((modIdx : ℕ) → (s' : Std.Iter ℕ) → motive (some (modIdx, s'))) → motive x | false |
Lean.Elab.WF.GuessLex.MutualMeasure.func | Lean.Elab.PreDefinition.WF.GuessLex | ℕ → Lean.Elab.WF.GuessLex.MutualMeasure | true |
Mathlib.Tactic.Peel.throwPeelError | Mathlib.Tactic.Peel | {α : Type} → Lean.Expr → Lean.Expr → Lean.MetaM α | true |
CategoryTheory.Functor.postcompose₃_map_app_app_app_app | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] {E : Type u_7}
[inst_3 : CategoryTheory.Category.{v_7, u_7} E] {E' : Type u_8} [inst_4 : CategoryTheory.Category.{v_8, u_8} E']
{X Y : CategoryTheory.Functor E E'} (f : X ⟶ Y)
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ E))) (c : C₁) (c_1 : C₂)
(c_2 : C₃),
((((CategoryTheory.Functor.postcompose₃.map f).app F).app c).app c_1).app c_2 = f.app (((F.obj c).obj c_1).obj c_2) | true |
Plausible.SampleableExt.casesOn | Plausible.Sampleable | {α : Sort u} →
{motive : Plausible.SampleableExt α → Sort u_1} →
(t : Plausible.SampleableExt α) →
((proxy : Type v) →
[proxyRepr : Repr proxy] →
[shrink : Plausible.Shrinkable proxy] →
[sample : Plausible.Arbitrary proxy] →
(interp : proxy → α) →
motive
{ proxy := proxy, proxyRepr := proxyRepr, shrink := shrink, sample := sample, interp := interp }) →
motive t | false |
AddCommGrpCat.hasColimit | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] [Small.{w, u} J] (F : CategoryTheory.Functor J AddCommGrpCat),
CategoryTheory.Limits.HasColimit F | true |
ENat.exists_eq_iInf | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} [Nonempty ι] (f : ι → ℕ∞), ∃ a, f a = ⨅ x, f x | true |
Equiv.toHomeomorphOfContinuousClosed._proof_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y),
Continuous ⇑e → IsClosedMap ⇑e → Topology.IsInducing ⇑e | false |
Std.IterM.attachWith.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] (it : Std.IterM m β)
(P : β → Prop) (h : ∀ (out : β), it.IsPlausibleIndirectOutput out → P out),
it.attachWith P h = { internalState := { inner := it, invariant := h } } | true |
Std.DTreeMap.Raw.Const.getD_inter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Raw.Const.getD (m₁ ∩ m₂) k fallback =
if m₂.contains k = true then Std.DTreeMap.Raw.Const.getD m₁ k fallback else fallback | true |
Lean.Meta.Grind.PreInstance.mk | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.PreInstance | true |
MvPolynomial.invertibleC._proof_1 | Mathlib.Algebra.MvPolynomial.Invertible | ∀ (σ : Type u_1) {R : Type u_2} [inst : CommSemiring R], MonoidHomClass (R →+* MvPolynomial σ R) R (MvPolynomial σ R) | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.mkPatternFromType.go._unsafe_rec | Lean.Meta.Sym.Pattern | List Lean.Name → Lean.Expr → ℕ → ℕ → Lean.Expr → Array Lean.Expr → Lean.MetaM Lean.Meta.Sym.Pattern | false |
RCLike.reCLM | Mathlib.Analysis.RCLike.Basic | {K : Type u_1} → [inst : RCLike K] → StrongDual ℝ K | true |
ExteriorAlgebra.liftAlternating._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.OfAlternating | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N], SMulCommClass R R ((i : ℕ) → M [⋀^Fin i]→ₗ[R] N) | false |
CategoryTheory.Functor.map_hom_inv | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [inst_2 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (F.map f) (F.map (CategoryTheory.inv f)) =
CategoryTheory.CategoryStruct.id (F.obj X) | true |
List.map₂Right | Mathlib.Data.List.Defs | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (Option α → β → γ) → List α → List β → List γ | true |
Std.Tactic.BVDecide.BVExpr.bitblast._proof_18 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w l r : ℕ), w = l + r → w = r + l | false |
Pi.faithfulSMul | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} [Nonempty ι] [inst : (i : ι) → SMul M (α i)]
[∀ (i : ι), Nonempty (α i)] [∀ (i : ι), FaithfulSMul M (α i)], FaithfulSMul M ((i : ι) → α i) | true |
AEMeasurable.sup' | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f g : α → M} [inst_1 : Max M] [MeasurableSup₂ M], AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (f ⊔ g) μ | true |
_private.Init.Data.List.ToArray.0.Array.findM?.match_1.eq_2 | Init.Data.List.ToArray | ∀ {α : Type} (motive : Option (Option α) → Sort u_1) (a : Option α) (h_1 : Unit → motive none)
(h_2 : (a : Option α) → motive (some a)),
(match some a with
| none => h_1 ()
| some a => h_2 a) =
h_2 a | true |
AddMonoidAlgebra.module.eq_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring R] [inst_1 : Semiring k] [inst_2 : Module R k],
AddMonoidAlgebra.module = { toDistribMulAction := AddMonoidAlgebra.distribMulAction, add_smul := ⋯, zero_smul := ⋯ } | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.splitter | Mathlib.SetTheory.Ordinal.Veblen | (o : Ordinal.{u_1}) →
(motive : { x // x ∈ Set.Iio o } → Sort u_2) →
(x : { x // x ∈ Set.Iio o }) → ((x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩) → motive x | true |
CategoryTheory.Limits.diagramIsoParallelFamily_inv_app | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor (CategoryTheory.Limits.WalkingParallelFamily J) C)
(X : CategoryTheory.Limits.WalkingParallelFamily J),
(CategoryTheory.Limits.diagramIsoParallelFamily F).inv.app X = CategoryTheory.eqToHom ⋯ | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.ofPoint_y | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (t : ↥(CategoryTheory.Limits.pullback f g)),
(AlgebraicGeometry.Scheme.Pullback.Triplet.ofPoint t).y = (CategoryTheory.Limits.pullback.snd f g) t | true |
_private.Mathlib.LinearAlgebra.RootSystem.Reduced.0.RootPairing.infinite_of_linearIndependent_coxeterWeight_four._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | false |
Std.Rco._sizeOf_inst | Init.Data.Range.Polymorphic.PRange | (α : Type u) → [SizeOf α] → SizeOf (Std.Rco α) | false |
FirstOrder.Language.BoundedFormula.restrictFreeVar.match_1 | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u_3} →
{β : Type u_5} →
[inst : DecidableEq α] →
(motive : (x : ℕ) → (x_1 : L.BoundedFormula α x) → (↥x_1.freeVarFinset → β) → Sort u_4) →
(x : ℕ) →
(x_1 : L.BoundedFormula α x) →
(x_2 : ↥x_1.freeVarFinset → β) →
((_n : ℕ) →
(_f : ↥FirstOrder.Language.BoundedFormula.falsum.freeVarFinset → β) →
motive _n FirstOrder.Language.BoundedFormula.falsum _f) →
((_n : ℕ) →
(t₁ t₂ : L.Term (α ⊕ Fin _n)) →
(f : ↥(FirstOrder.Language.BoundedFormula.equal t₁ t₂).freeVarFinset → β) →
motive _n (FirstOrder.Language.BoundedFormula.equal t₁ t₂) f) →
((_n l : ℕ) →
(R : L.Relations l) →
(ts : Fin l → L.Term (α ⊕ Fin _n)) →
(f : ↥(FirstOrder.Language.BoundedFormula.rel R ts).freeVarFinset → β) →
motive _n (FirstOrder.Language.BoundedFormula.rel R ts) f) →
((_n : ℕ) →
(φ₁ φ₂ : L.BoundedFormula α _n) →
(f : ↥(φ₁.imp φ₂).freeVarFinset → β) → motive _n (φ₁.imp φ₂) f) →
((_n : ℕ) →
(φ : L.BoundedFormula α (_n + 1)) → (f : ↥φ.all.freeVarFinset → β) → motive _n φ.all f) →
motive x x_1 x_2 | false |
CategoryTheory.ObjectProperty.unop_monotone | Mathlib.CategoryTheory.ObjectProperty.Opposite | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {P Q : CategoryTheory.ObjectProperty Cᵒᵖ},
P ≤ Q → P.unop ≤ Q.unop | true |
Filter.comap_prodMap_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ) (lb : Filter β) (ld : Filter δ),
Filter.comap (Prod.map f g) (lb ×ˢ ld) = Filter.comap f lb ×ˢ Filter.comap g ld | true |
Std.Time.Year.Era.bce.elim | Std.Time.Date.Unit.Year | {motive : Std.Time.Year.Era → Sort u} →
(t : Std.Time.Year.Era) → t.ctorIdx = 0 → motive Std.Time.Year.Era.bce → motive t | false |
CategoryTheory.InducedCategory.Hom._sizeOf_1 | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v, u₂} D} →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → [SizeOf C] → [SizeOf D] → X.Hom Y → ℕ | false |
SimpleGraph.Walk.IsTrail.isCycle_cycleBypass | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {v : V} {w : G.Walk v v},
w ≠ SimpleGraph.Walk.nil → w.IsTrail → w.cycleBypass.IsCycle | true |
FirstOrder.Language.Embedding.substructureEquivMap._proof_2 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (n : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
↑n ∈ FirstOrder.Language.Substructure.map f.toHom s | false |
CategoryTheory.AddMon.forget_map | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : CategoryTheory.AddMon C} (f : X ⟶ Y), (CategoryTheory.AddMon.forget C).map f = f.hom | true |
Lean.Elab.Tactic.evalWithUnfoldingAll | Lean.Elab.Tactic.ElabTerm | Lean.Elab.Tactic.Tactic | true |
CategoryTheory.exponentialIdeal_of_preservesBinaryProducts | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
(i : CategoryTheory.Functor D C) [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
[inst_3 : CategoryTheory.Reflective i] [inst_4 : CategoryTheory.MonoidalClosed C]
[CategoryTheory.CartesianMonoidalCategory D]
[CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
(CategoryTheory.reflector i)],
CategoryTheory.ExponentialIdeal i | true |
DerivedCategory.instLinear | Mathlib.Algebra.Homology.DerivedCategory.Linear | (R : Type t) →
[inst : Ring R] →
(C : Type u) →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Abelian C] →
[CategoryTheory.Linear R C] → [inst_4 : HasDerivedCategory C] → CategoryTheory.Linear R (DerivedCategory C) | true |
meromorphicOrderAt_pow | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {f : 𝕜 → 𝕜} {x : 𝕜},
MeromorphicAt f x → ∀ {n : ℕ}, meromorphicOrderAt (f ^ n) x = ↑n * meromorphicOrderAt f x | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow._sizeOf_inst | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X : C} → {J : CategoryTheory.GrothendieckTopology C} → (S : J.Cover X) → [SizeOf C] → SizeOf S.Arrow | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.OfKernel.kerFun._simp_1 | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b : α} [inst_1 : Preorder α] [PosMulMono α],
0 ≤ a → 0 ≤ b → (0 ≤ a * b) = True | false |
_private.Lean.Util.FindMVar.0.Lean.FindMVar.main.match_1 | Lean.Util.FindMVar | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName d b binderInfo)) →
((declName : Lean.Name) →
(t v b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName t v b nondep)) →
((f a : Lean.Expr) → motive (f.app a)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → ((x : Lean.Expr) → motive x) → motive x | false |
String.Pos.Raw.IsValid.isValidUTF8_extract_zero | Init.Data.String.Defs | ∀ {s : String} {off : String.Pos.Raw}, String.Pos.Raw.IsValid s off → (s.toByteArray.extract 0 off.byteIdx).IsValidUTF8 | true |
pow_two_semiclosed | Mathlib.Algebra.Order.Group.Lattice | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] [MulLeftMono α] [MulRightMono α] {a : α}, 1 ≤ a ^ 2 → 1 ≤ a | true |
CategoryTheory.Functor.Full.mk._flat_ctor | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D}, (∀ {X Y : C}, Function.Surjective F.map) → F.Full | false |
AlgebraicGeometry.instUniqueI₀SchemeCover._proof_3 | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (hf : P f)
[inst : AlgebraicGeometry.Surjective f] (a : (AlgebraicGeometry.Scheme.Hom.cover f hf).I₀), a = default | false |
AlgebraicGeometry.specZIsTerminal._proof_1 | Mathlib.AlgebraicGeometry.Limits | CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty CommRingCatᵒᵖ) AlgebraicGeometry.Scheme.Spec | false |
CategoryTheory.MonoidalCategory.associator_naturality_middle_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C) {Y Y' : C}
(f : Y ⟶ Y') (Z : C) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y' Z) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f) Z)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y' Z).hom h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z))
h) | true |
Bool.not_eq_false | Init.SimpLemmas | ∀ (b : Bool), (¬b = false) = (b = true) | true |
FirstOrder.Ring.oneFunc | Mathlib.ModelTheory.Algebra.Ring.Basic | FirstOrder.Language.ring.Functions 0 | true |
Matrix.kroneckerTMulStarAlgEquiv._proof_1 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_1) (n : Type u_2) (R : Type u_5) (S : Type u_6) (A : Type u_3) (B : Type u_4) [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algebra S A]
[inst_10 : IsScalarTower R S A] [inst_11 : Fintype m] [inst_12 : DecidableEq m] [inst_13 : StarRing R]
[inst_14 : StarAddMonoid A] [inst_15 : StarAddMonoid B] [inst_16 : StarModule R A] [inst_17 : StarModule R B],
(Matrix.kroneckerTMulAlgEquiv m n R S A B) (star 0) = star ((Matrix.kroneckerTMulAlgEquiv m n R S A B) 0) | false |
NonUnitalStarSubalgebra.isClosed_topologicalClosure | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : Star A]
[inst_3 : NonUnitalSemiring A] [inst_4 : Module R A] [inst_5 : ContinuousStar A] [inst_6 : ContinuousConstSMul R A]
[inst_7 : IsSemitopologicalSemiring A] (s : NonUnitalStarSubalgebra R A), IsClosed ↑s.topologicalClosure | true |
PolynomialLaw.smul._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (r : R) (f : M →ₚₗ[R] N) {S : Type u_1} [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] {S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S'),
⇑(LinearMap.rTensor N φ.toLinearMap) ∘ (r • f.toFun' S) = (r • f.toFun' S') ∘ ⇑(LinearMap.rTensor M φ.toLinearMap) | false |
CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id_assoc | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
[inst_6 : CategoryTheory.Limits.PreservesFiniteColimits F] {Z : CategoryTheory.Functor C D} (h : F.leftDerived 0 ⟶ Z),
CategoryTheory.CategoryStruct.comp F.fromLeftDerivedZero
(CategoryTheory.CategoryStruct.comp F.leftDerivedZeroIsoSelf.inv h) =
h | true |
List.isNone_findFinIdx? | Init.Data.List.Find | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (List.findFinIdx? p l).isNone = l.all fun x => decide ¬p x = true | true |
Lean.LocalContext.noConfusion | Lean.LocalContext | {P : Sort u} → {t t' : Lean.LocalContext} → t = t' → Lean.LocalContext.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject.0.HomotopyCategory.composableArrowsFunctor._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ¬0 ≤ 1 → False | false |
HomogeneousSubmodule.mk.inj | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Submodule | ∀ {ιA : Type u_1} {ιM : Type u_2} {σA : Type u_3} {σM : Type u_4} {A : Type u_5} {M : Type u_6} {inst : Semiring A}
{inst_1 : AddCommMonoid M} {inst_2 : Module A M} {𝒜 : ιA → σA} {ℳ : ιM → σM} {inst_3 : DecidableEq ιA}
{inst_4 : AddMonoid ιA} {inst_5 : SetLike σA A} {inst_6 : AddSubmonoidClass σA A} {inst_7 : GradedRing 𝒜}
{inst_8 : DecidableEq ιM} {inst_9 : SetLike σM M} {inst_10 : AddSubmonoidClass σM M}
{inst_11 : DirectSum.Decomposition ℳ} {inst_12 : VAdd ιA ιM} {inst_13 : SetLike.GradedSMul 𝒜 ℳ}
{toSubmodule : Submodule A M} {is_homogeneous' : toSubmodule.IsHomogeneous ℳ} {toSubmodule_1 : Submodule A M}
{is_homogeneous'_1 : toSubmodule_1.IsHomogeneous ℳ},
{ toSubmodule := toSubmodule, is_homogeneous' := is_homogeneous' } =
{ toSubmodule := toSubmodule_1, is_homogeneous' := is_homogeneous'_1 } →
toSubmodule = toSubmodule_1 | true |
PiTensorProduct.map₂ | Mathlib.LinearAlgebra.PiTensorProduct | {ι : Type u_1} →
{R : Type u_4} →
[inst : CommSemiring R] →
{s : ι → Type u_7} →
[inst_1 : (i : ι) → AddCommMonoid (s i)] →
[inst_2 : (i : ι) → Module R (s i)] →
{t : ι → Type u_11} →
{t' : ι → Type u_12} →
[inst_3 : (i : ι) → AddCommMonoid (t i)] →
[inst_4 : (i : ι) → Module R (t i)] →
[inst_5 : (i : ι) → AddCommMonoid (t' i)] →
[inst_6 : (i : ι) → Module R (t' i)] →
((i : ι) → s i →ₗ[R] t i →ₗ[R] t' i) →
(PiTensorProduct R fun i => s i) →ₗ[R]
(PiTensorProduct R fun i => t i) →ₗ[R] PiTensorProduct R fun i => t' i | true |
CategoryTheory.AB4StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
{motive : CategoryTheory.AB4StarOfSize.{w, v, u} C → Sort u_1} →
((ofShape : ∀ (α : Type w), CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete α) C) → motive ⋯) →
(t : CategoryTheory.AB4StarOfSize.{w, v, u} C) → motive t | false |
Classical.Order.instLT | Init.Data.Order.Lemmas | {α : Type u} → [LE α] → LT α | true |
Lean.MessageDataContext.mk.sizeOf_spec | Lean.Message | ∀ (env : Lean.Environment) (mctx : Lean.MetavarContext) (lctx : Lean.LocalContext) (opts : Lean.Options),
sizeOf { env := env, mctx := mctx, lctx := lctx, opts := opts } =
1 + sizeOf env + sizeOf mctx + sizeOf lctx + sizeOf opts | true |
Function.Embedding.coe_quotientOut | Mathlib.Logic.Embedding.Basic | ∀ (α : Sort u_1) [inst : Setoid α], ⇑(Function.Embedding.quotientOut α) = Quotient.out | true |
_private.Mathlib.Algebra.Order.Ring.Archimedean.0.ArchimedeanClass.instLinearOrderedAddCommMonoidWithTop._simp_2 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
x ≠ 0 → IsAddRegular (ArchimedeanClass.mk x) = True | false |
CategoryTheory.MorphismProperty.HasLocalization.D | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(W : CategoryTheory.MorphismProperty C) → [self : W.HasLocalization] → Type u | true |
CategoryTheory.Presheaf.freeYonedaHomEquiv_comp | Mathlib.CategoryTheory.Generator.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] {X : C} {M : A} {F G : CategoryTheory.Functor Cᵒᵖ A}
(α : CategoryTheory.Presheaf.freeYoneda X M ⟶ F) (f : F ⟶ G),
CategoryTheory.Presheaf.freeYonedaHomEquiv (CategoryTheory.CategoryStruct.comp α f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.freeYonedaHomEquiv α) (f.app (Opposite.op X)) | true |
_private.Mathlib.Analysis.Normed.Module.RCLike.Basic.0.LinearMap.bound_of_sphere_bound._simp_1_3 | Mathlib.Analysis.Normed.Module.RCLike.Basic | (¬False) = True | false |
geom_sum_of_one_lt | Mathlib.Algebra.Order.Field.GeomSum | ∀ {K : Type u_1} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [CanonicallyOrderedAdd K]
[inst_4 : Sub K] [OrderedSub K] {x : K}, 1 < x → ∀ (n : ℕ), ∑ i ∈ Finset.range n, x ^ i = (x ^ n - 1) / (x - 1) | true |
_private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.Operands | Mathlib.SetTheory.Cardinal.Subfield | {α : Type u} → (s : Set α) → Fin 6 ⊕ ↑s → Type | true |
Int.add_right_inj._simp_1 | Init.Data.Int.Lemmas | ∀ {i j : ℤ} (k : ℤ), (k + i = k + j) = (i = j) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.