name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
curveIntegralFun_cast | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b c d : E}
(ω : E → E →L[𝕜] F) (γ : Path a b) (hc : c = a) (hd : d = b), curveIntegralFun ω (γ.cast hc hd) = curveIntegralFun ω γ | true |
CategoryTheory.Classifier.mkOfTerminalΩ₀_truth | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (Ω₀ : C) (t : CategoryTheory.Limits.IsTerminal Ω₀) (Ω : C)
(truth : Ω₀ ⟶ Ω) (χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω)
(isPullback :
∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m], CategoryTheory.IsPullback m (t.from U) (χ m) truth)
(uniq :
∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m] (χ' : X ⟶ Ω),
CategoryTheory.IsPullback m (t.from U) χ' truth → χ' = χ m),
(CategoryTheory.Classifier.mkOfTerminalΩ₀ Ω₀ t Ω truth χ isPullback uniq).truth = truth | true |
IsTopologicalGroup.toHSpace._proof_4 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : MulOneClass M], 1 * 1 = 1 | false |
AdjoinRoot.powerBasis.eq_1 | Mathlib.FieldTheory.Galois.NormalBasis | ∀ {K : Type u_5} [inst : Field K] {f : Polynomial K} (hf : f ≠ 0),
AdjoinRoot.powerBasis hf =
{ gen := AdjoinRoot.root f, dim := f.natDegree, basis := AdjoinRoot.powerBasisAux hf, basis_eq_pow := ⋯ } | true |
Std.DTreeMap.Internal.Unit.RicSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Unit.RicSliceData α → Sort u_1} →
(t : Std.DTreeMap.Internal.Unit.RicSliceData α) →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
motive t | false |
Lean.Meta.Tactic.TryThis.Suggestion.preInfo? | Lean.Meta.TryThis | Lean.Meta.Tactic.TryThis.Suggestion → Option String | true |
Matroid.closure_inter_ground | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} (M : Matroid α) (X : Set α), M.closure (X ∩ M.E) = M.closure X | true |
Lean.IR.FnBody.sset.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} →
{x : Lean.IR.VarId} →
{i offset : ℕ} →
{y : Lean.IR.VarId} →
{ty : Lean.IR.IRType} →
{b : Lean.IR.FnBody} →
{x' : Lean.IR.VarId} →
{i' offset' : ℕ} →
{y' : Lean.IR.VarId} →
{ty' : Lean.IR.IRType} →
{b' : Lean.IR.FnBody} →
Lean.IR.FnBody.sset x i offset y ty b = Lean.IR.FnBody.sset x' i' offset' y' ty' b' →
(x = x' → i = i' → offset = offset' → y = y' → ty = ty' → b = b' → P) → P | false |
Bornology.IsBounded.image_eval | Mathlib.Topology.Bornology.Constructions | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (i : ι) → Bornology (X i)] {s : Set ((i : ι) → X i)},
Bornology.IsBounded s → ∀ (i : ι), Bornology.IsBounded (Function.eval i '' s) | true |
SmoothBumpFunction.instNonempty | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M},
Nonempty (SmoothBumpFunction I c) | true |
List.traverse_cons | Mathlib.Control.Traversable.Instances | ∀ {F : Type u → Type u} [inst : Applicative F] {α' β' : Type u} (f : α' → F β') (a : α') (l : List α'),
traverse f (a :: l) = (fun x1 x2 => x1 :: x2) <$> f a <*> traverse f l | true |
Std.CancellationToken.noConfusionType | Std.Sync.CancellationToken | Sort u → Std.CancellationToken → Std.CancellationToken → Sort u | false |
«term_≃ₗᵢ⋆[_]_» | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.TrailingParserDescr | true |
AlgebraicGeometry.IsAffineOpen.fromSpecStalk.eq_1 | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U) {x : ↥X} (hxU : x ∈ U),
hU.fromSpecStalk hxU =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (X.presheaf.germ U x hxU)) hU.fromSpec | true |
Lean.MVarId.propext | Lean.Meta.Tactic.Apply | Lean.MVarId → Lean.MetaM Lean.MVarId | true |
AlgebraicGeometry.Scheme.PartialMap.restrict_domain | Mathlib.AlgebraicGeometry.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialMap Y) (U : X.Opens) (hU : Dense ↑U) (hU' : U ≤ f.domain),
(f.restrict U hU hU').domain = U | true |
StrictConvex.neg | Mathlib.Analysis.Convex.Strict | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : TopologicalSpace E]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {s : Set E} [IsTopologicalAddGroup E],
StrictConvex 𝕜 s → StrictConvex 𝕜 (-s) | true |
CategoryTheory.Sieve.mem_functorPushforward_inverse | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{Y : C} {X : D} {S : CategoryTheory.Sieve X} {e : C ≌ D} {f : Y ⟶ e.inverse.obj X},
(CategoryTheory.Sieve.functorPushforward e.inverse S).arrows f ↔
S.arrows (CategoryTheory.CategoryStruct.comp (e.functor.map f) (e.counit.app X)) | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction._proof_13 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : Dᵒᵖ} (x : d ⟶ d'),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso (Opposite.unop d)).symm.op.hom x =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight
(Opposite.unop (CategoryTheory.MonoidalCategoryStruct.tensorUnit Cᵒᵖ)) x.unop).op
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso (Opposite.unop d')).symm.op.hom | false |
lowerClosure_eq._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, (↑(lowerClosure s) = s) = IsLowerSet s | false |
Nat.ModEq.mul_right_cancel' | Mathlib.Data.Nat.ModEq | ∀ {a b c m : ℕ}, c ≠ 0 → a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m] | true |
HasSSubset.SSubset.trans_eq | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSSubset α] {a b c : α}, a ⊂ b → b = c → a ⊂ c | true |
Filter.isBoundedUnder_of | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {f : Filter β} {u : β → α},
(∃ b, ∀ (x : β), r (u x) b) → Filter.IsBoundedUnder r f u | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr_trans_hom_assoc | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} {x y z : AlgebraicGeometry.Scheme.Pullback.Triplet f g}
(e : x = y) (e' : y = z) {Z : CommRingCat} (h : z.tensor ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e).hom
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e').hom h) =
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr ⋯).hom h | true |
Std.ExtTreeMap.contains_insertMany_list | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α},
(t.insertMany l).contains k = (t.contains k || (List.map Prod.fst l).contains k) | true |
CategoryTheory.Triangulated.Octahedron.casesOn | 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₁₂ : X₂ ⟶ Z₁₂} →
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₂ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₂₃ : X₃ ⟶ Z₂₃} →
{w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂} →
{h₂₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₁₃ : X₃ ⟶ Z₁₃} →
{w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{motive : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃ → Sort u} →
(t : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃) →
((m₁ : Z₁₂ ⟶ Z₁₃) →
(m₃ : Z₁₃ ⟶ Z₂₃) →
(comm₁ :
CategoryTheory.CategoryStruct.comp v₁₂ m₁ =
CategoryTheory.CategoryStruct.comp u₂₃ v₁₃) →
(comm₂ : CategoryTheory.CategoryStruct.comp m₁ w₁₃ = w₁₂) →
(comm₃ : CategoryTheory.CategoryStruct.comp v₁₃ m₃ = v₂₃) →
(comm₄ :
CategoryTheory.CategoryStruct.comp w₁₃
((CategoryTheory.shiftFunctor C 1).map u₁₂) =
CategoryTheory.CategoryStruct.comp m₃ w₂₃) →
(mem :
CategoryTheory.Pretriangulated.Triangle.mk m₁ m₃
(CategoryTheory.CategoryStruct.comp w₂₃
((CategoryTheory.shiftFunctor C 1).map v₁₂)) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
motive
{ m₁ := m₁, m₃ := m₃, comm₁ := comm₁, comm₂ := comm₂,
comm₃ := comm₃, comm₄ := comm₄, mem := mem }) →
motive t | false |
StrictConvexOn.convex_lt | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 β]
[IsOrderedAddMonoid β] [PosSMulMono 𝕜 β] {s : Set E} {f : E → β},
StrictConvexOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ f x < r} | true |
HomologicalComplex.homotopyCofiber.sndX.eq_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i : ι),
HomologicalComplex.homotopyCofiber.sndX φ i =
if hi : c.Rel i (c.next i) then
CategoryTheory.CategoryStruct.comp (HomologicalComplex.homotopyCofiber.XIsoBiprod φ i (c.next i) hi).hom
CategoryTheory.Limits.biprod.snd
else (HomologicalComplex.homotopyCofiber.XIso φ i hi).hom | true |
Lean.Meta.Grind.Origin.key | Lean.Meta.Tactic.Grind.Theorems | Lean.Meta.Grind.Origin → Lean.Name | true |
Lean.Meta.LazyDiscrTree.Key.proj.sizeOf_spec | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.Name) (a_1 a_2 : ℕ),
sizeOf (Lean.Meta.LazyDiscrTree.Key.proj a a_1 a_2) = 1 + sizeOf a + sizeOf a_1 + sizeOf a_2 | true |
IterateAddAct.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} → {f : α → α} → ℕ → IterateAddAct f | false |
ULift.up_ofNat | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u} [inst : NatCast R] (n : ℕ) [inst_1 : n.AtLeastTwo], { down := OfNat.ofNat n } = OfNat.ofNat n | true |
Lean.Server.Test.Runner.Client.Hyp.isRemoved? | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.Hyp → Option Bool | true |
Lean.Parser.Term.doLetElse.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | true |
Matrix.kroneckerTMulStarAlgEquiv._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_1) (n : Type u_3) (R : Type u_5) (S : Type u_6) (A : Type u_2) (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]
(x : Matrix m m A) (y : Matrix n n B),
(Matrix.kroneckerTMulAlgEquiv m n R S A B) (star (x ⊗ₜ[R] y)) =
star ((Matrix.kroneckerTMulAlgEquiv m n R S A B) (x ⊗ₜ[R] y)) | false |
Matrix.eRank_toNat_eq_finrank | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} {R : Type uR} [inst : Semiring R] (A : Matrix m n R),
A.eRank.toNat = Module.finrank R ↥(Submodule.span R (Set.range A.col)) | true |
Mathlib.Tactic.BicategoryLike.MkEvalWhiskerLeft | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (Type → Type) → Type | true |
_private.Mathlib.Tactic.ProxyType.0.Mathlib.ProxyType.ensureProxyEquiv.match_3 | Mathlib.Tactic.ProxyType | (motive :
Option
((Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term) ×
Subarray (Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term)) →
Sort u_1) →
(x :
Option
((Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term) ×
Subarray (Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term))) →
(Unit → motive none) →
((fst : Lean.Name) →
(fst_1 : Lean.Expr) →
(fst_2 : Lean.Term) →
(cpatt : Lean.TSyntax `term) →
(s' : Subarray (Lean.Name × Lean.Expr × Lean.Term × Lean.TSyntax `term)) →
motive (some ((fst, fst_1, fst_2, cpatt), s'))) →
motive x | false |
_private.Init.Data.Array.Lemmas.0.Array.ne_of_not_mem_push._simp_1_1 | Init.Data.Array.Lemmas | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
StrictConvexOn.slope_lt_of_hasDerivWithinAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ},
StrictConvexOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivWithinAt f f' S y → slope f x y < f' | true |
Seminorm.mk | Mathlib.Analysis.Seminorm | {𝕜 : Type u_12} →
{E : Type u_13} →
[inst : SeminormedRing 𝕜] →
[inst_1 : AddGroup E] →
[inst_2 : SMul 𝕜 E] →
(toAddGroupSeminorm : AddGroupSeminorm E) →
(∀ (a : 𝕜) (x : E), toAddGroupSeminorm.toFun (a • x) = ‖a‖ * toAddGroupSeminorm.toFun x) → Seminorm 𝕜 E | true |
CategoryTheory.IsFiltered.SmallFilteredIntermediate.factoring | Mathlib.CategoryTheory.Filtered.Small | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.IsFilteredOrEmpty C] →
{D : Type u₁} →
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] →
(F : CategoryTheory.Functor D C) →
CategoryTheory.Functor D (CategoryTheory.IsFiltered.SmallFilteredIntermediate F) | true |
Module.Finite.self | Mathlib.RingTheory.Finiteness.Basic | ∀ (R : Type u_1) [inst : Semiring R], Module.Finite R R | true |
inv_mul_lt_iff₀' | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b c : G₀},
0 < c → (c⁻¹ * b < a ↔ b < a * c) | true |
Filter.Germ.instIsCancelMul | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : Mul M] [IsCancelMul M], IsCancelMul (l.Germ M) | true |
Lean.parseImports' | Lean.Elab.ParseImportsFast | String → String → IO Lean.ModuleHeader | true |
Algebra.lmul._proof_3 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
IsScalarTower R R A | false |
Filter.high_scores | Mathlib.Order.Filter.AtTopBot.Finite | ∀ {β : Type u_4} [inst : LinearOrder β] [NoMaxOrder β] {u : ℕ → β},
Filter.Tendsto u Filter.atTop Filter.atTop → ∀ (N : ℕ), ∃ n ≥ N, ∀ k < n, u k < u n | true |
LieAlgebra.lieCharacterEquivLinearDual_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(χ : LieAlgebra.LieCharacter R L), LieAlgebra.lieCharacterEquivLinearDual χ = ↑χ | true |
IsDomain.recOn | Mathlib.Algebra.Ring.Defs | {α : Type u} →
[inst : Semiring α] →
{motive : IsDomain α → Sort u_1} →
(t : IsDomain α) → ([toIsCancelMulZero : IsCancelMulZero α] → [toNontrivial : Nontrivial α] → motive ⋯) → motive t | false |
FreeCommRing.eq_1 | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u), FreeCommRing α = FreeAbelianGroup (Multiplicative (Multiset α)) | true |
CategoryTheory.Limits.colimitFlipCompColimIsoColimitCompColim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
[CategoryTheory.Limits.HasColimitsOfShape K C],
CategoryTheory.Limits.HasColimit (F.flip.comp CategoryTheory.Limits.colim) | false |
Std.Tactic.BVDecide.BVExpr.Cache.Inv | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | Std.Tactic.BVDecide.BVExpr.Assignment →
(aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) → Std.Tactic.BVDecide.BVExpr.Cache aig → Prop | true |
CategoryTheory.ObjectProperty.ι_obj_lift_map | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) {X Y : C}
(f : X ⟶ Y), P.ι.map ((P.lift F hF).map f) = F.map f | true |
CategoryTheory.Triangulated.TStructure.isLE_of_le | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | ∀ {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]
(t : CategoryTheory.Triangulated.TStructure C) (X : C) (p q : ℤ),
autoParam (p ≤ q) CategoryTheory.Triangulated.TStructure.isLE_of_le._auto_1 → ∀ [t.IsLE X p], t.IsLE X q | true |
groupHomology.H1CoresCoinfOfTrivial_g_epi | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (S : Subgroup G) [inst_2 : S.Normal]
[inst_3 : Representation.IsTrivial (MonoidHom.comp A.ρ S.subtype)],
CategoryTheory.Epi (groupHomology.H1CoresCoinfOfTrivial A S).g | true |
Asymptotics.isBigOWith_norm_right._simp_1 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {c : ℝ} {f : α → E}
{g' : α → F'} {l : Filter α}, (Asymptotics.IsBigOWith c l f fun x => ‖g' x‖) = Asymptotics.IsBigOWith c l f g' | false |
Metric.smul_eball | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : Group G] [inst_2 : MulAction G X]
[IsIsometricSMul G X] (c : G) (x : X) (r : ENNReal), c • Metric.eball x r = Metric.eball (c • x) r | true |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.«term_†» | Mathlib.Analysis.InnerProductSpace.Defs | Lean.TrailingParserDescr | true |
PerfectClosure.of | Mathlib.FieldTheory.PerfectClosure | (K : Type u) →
[inst : CommRing K] → (p : ℕ) → [inst_1 : Fact (Nat.Prime p)] → [inst_2 : CharP K p] → K →+* PerfectClosure K p | true |
SSet.Truncated.IsStrictSegal.mk | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)},
(∀ (m : ℕ) (h : autoParam (m ≤ n + 1) SSet.Truncated.IsStrictSegal._auto_1), Function.Bijective (X.spine m h)) →
X.IsStrictSegal | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.recOn | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G → Sort u} →
(t : CategoryTheory.Adjunction.CoreHomEquivUnitCounit F G) →
((homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) →
(unit : CategoryTheory.Functor.id C ⟶ F.comp G) →
(counit : G.comp F ⟶ CategoryTheory.Functor.id D) →
(homEquiv_unit :
∀ {X : C} {Y : D} {f : F.obj X ⟶ Y},
(homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (unit.app X) (G.map f)) →
(homEquiv_counit :
∀ {X : C} {Y : D} {g : X ⟶ G.obj Y},
(homEquiv X Y).symm g = CategoryTheory.CategoryStruct.comp (F.map g) (counit.app Y)) →
motive
{ homEquiv := homEquiv, unit := unit, counit := counit, homEquiv_unit := homEquiv_unit,
homEquiv_counit := homEquiv_counit }) →
motive t | false |
CategoryTheory.FunctorToTypes.naturality_symm | Mathlib.CategoryTheory.Types.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type u_1)}
{G : CategoryTheory.Functor C (Type u_2)} (e : (j : C) → F.obj j ≃ G.obj j),
(∀ {j j' : C} (f : j ⟶ j'), ⇑(e j') ∘ F.map f = G.map f ∘ ⇑(e j)) →
∀ {j j' : C} (f : j ⟶ j'), ⇑(e j').symm ∘ G.map f = F.map f ∘ ⇑(e j).symm | true |
Equiv.Perm.extendDomain_eq_one_iff._simp_1 | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] {e : Equiv.Perm α} {f : α ≃ Subtype p},
(e.extendDomain f = 1) = (e = 1) | false |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.CauSeq.not_limZero_of_pos.match_1_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {f : CauSeq α abs} (w : α)
(w_1 : ℕ) (motive : w ≤ ↑f w_1 ∧ |↑f w_1| < w → Prop) (x : w ≤ ↑f w_1 ∧ |↑f w_1| < w),
(∀ (h₁ : w ≤ ↑f w_1) (h₂ : |↑f w_1| < w), motive ⋯) → motive x | false |
Sym2.fromRel_top_iff | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r}, Sym2.fromRel sym = Set.univ ↔ r = ⊤ | true |
Module.finrank_directSum | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ (R : Type u) [inst : Semiring R] [StrongRankCondition R] {ι : Type v} [inst_2 : Fintype ι] (M : ι → Type w)
[inst_3 : (i : ι) → AddCommMonoid (M i)] [inst_4 : (i : ι) → Module R (M i)] [∀ (i : ι), Module.Free R (M i)]
[∀ (i : ι), Module.Finite R (M i)], Module.finrank R (DirectSum ι fun i => M i) = ∑ i, Module.finrank R (M i) | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_lt_natAbs_self_of_lt_neg_one_of_lt_neg_one._simp_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ} (c : ℤ), (a + c < b + c) = (a < b) | false |
_private.Batteries.Linter.UnreachableTactic.0.Batteries.Linter.UnreachableTactic.ignoreTacticKindsRef._proof_1 | Batteries.Linter.UnreachableTactic | Nonempty (ST.Ref IO.RealWorld Lean.NameHashSet) | false |
Polynomial.isIntegral_isLocalization_polynomial_quotient | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] {Rₘ : Type u_3} {Sₘ : Type u_4} [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(P : Ideal (Polynomial R)),
∀ pX ∈ P,
∀ [inst_3 : Algebra (R ⧸ Ideal.comap Polynomial.C P) Rₘ]
[inst_4 :
IsLocalization.Away (Polynomial.map (Ideal.Quotient.mk (Ideal.comap Polynomial.C P)) pX).leadingCoeff Rₘ]
[inst_5 : Algebra (Polynomial R ⧸ P) Sₘ]
[inst_6 :
IsLocalization
(Submonoid.map (Ideal.quotientMap P Polynomial.C ⋯)
(Submonoid.powers (Polynomial.map (Ideal.Quotient.mk (Ideal.comap Polynomial.C P)) pX).leadingCoeff))
Sₘ],
(IsLocalization.map Sₘ (Ideal.quotientMap P Polynomial.C ⋯) ⋯).IsIntegral | true |
CategoryTheory.ExponentiableMorphism.pushforwardComp | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J K : C} →
(f : I ⟶ J) →
(g : J ⟶ K) →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
[inst_2 : CategoryTheory.ChosenPullbacksAlong g] →
[inst_3 : CategoryTheory.ChosenPullbacksAlong (CategoryTheory.CategoryStruct.comp f g)] →
[inst_4 : CategoryTheory.ExponentiableMorphism f] →
[inst_5 : CategoryTheory.ExponentiableMorphism g] →
[inst_6 : CategoryTheory.ExponentiableMorphism (CategoryTheory.CategoryStruct.comp f g)] →
CategoryTheory.ExponentiableMorphism.pushforward (CategoryTheory.CategoryStruct.comp f g) ≅
(CategoryTheory.ExponentiableMorphism.pushforward f).comp
(CategoryTheory.ExponentiableMorphism.pushforward g) | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.foldM.match_1.eq_2 | Batteries.Data.PairingHeap | ∀ {α : Type u_1} (motive : Option (α × Batteries.PairingHeapImp.Heap α) → Sort u_2) (hd : α)
(tl : Batteries.PairingHeapImp.Heap α) (h_1 : some (hd, tl) = none → motive none)
(h_2 :
(hd_1 : α) →
(tl_1 : Batteries.PairingHeapImp.Heap α) → some (hd, tl) = some (hd_1, tl_1) → motive (some (hd_1, tl_1))),
(match eq : some (hd, tl) with
| none => h_1 eq
| some (hd_1, tl_1) => h_2 hd_1 tl_1 eq) =
h_2 hd tl ⋯ | true |
Lean.Elab.Command.removeFunctorPostfix | Lean.Elab.Coinductive | Lean.Name → Lean.Name | true |
CategoryTheory.GradedObject.mapIso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X Y : CategoryTheory.GradedObject I C} (e : X ≅ Y) (p : I → J) [inst_1 : X.HasMap p] [inst_2 : Y.HasMap p] (i : J),
(CategoryTheory.GradedObject.mapIso e p).hom i = CategoryTheory.GradedObject.mapMap e.hom p i | true |
Equiv.sumArrowEquivProdArrow_symm_apply_inl | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} {γ : Type u_11} (f : α → γ) (g : β → γ) (a : α),
(Equiv.sumArrowEquivProdArrow α β γ).symm (f, g) (Sum.inl a) = f a | true |
Lean.Meta.Grind.Arith.Cutsat.VarInfo.maxDvdCoeff | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Lean.Meta.Grind.Arith.Cutsat.VarInfo → ℕ | true |
Lean.Meta.Grind.AC.DiseqCnstr.setUnsat | Lean.Meta.Tactic.Grind.AC.Proof | Lean.Meta.Grind.AC.DiseqCnstr → Lean.Meta.Grind.AC.ACM Unit | true |
Std.Iterators.PostconditionT.operation_pure | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Monad m] {α : Type w} {x : α}, (pure x).operation = pure ⟨x, ⋯⟩ | true |
IsTopologicalAddGroup.toHSpace._proof_4 | Mathlib.Topology.Homotopy.HSpaces | ∀ (M : Type u_1) [inst : AddZeroClass M], 0 + 0 = 0 | false |
LocalizedModule.smulOfIsLocalization._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (T : Type u_3) [inst_3 : CommSemiring T] [inst_4 : Algebra R T] [inst_5 : IsLocalization S T]
(x : T) (p p' : M × ↥S),
p ≈ p' →
(fun p => LocalizedModule.mk ((IsLocalization.sec S x).1 • p.1) ((IsLocalization.sec S x).2 * p.2)) p =
(fun p => LocalizedModule.mk ((IsLocalization.sec S x).1 • p.1) ((IsLocalization.sec S x).2 * p.2)) p' | false |
Nat.prod_Icc_factorial | Mathlib.Data.Nat.Factorial.SuperFactorial | ∀ (n : ℕ), ∏ x ∈ Finset.Icc 1 n, x.factorial = n.superFactorial | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_12 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (A : C) (a : (F.obj A).obj)
(isGalois : CategoryTheory.PreGaloisCategory.IsGalois A) (B : C) (b : (F.obj B).obj)
(isGalois_1 : CategoryTheory.PreGaloisCategory.IsGalois B)
(f :
(Opposite.unop (Opposite.op { obj := B, pt := b, isGalois := isGalois_1 })).obj ⟶
(Opposite.unop (Opposite.op { obj := A, pt := a, isGalois := isGalois })).obj)
(hf : (CategoryTheory.ConcreteCategory.hom (F.map f)) b = a),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl F).op.comp CategoryTheory.coyoneda).map
(Opposite.op { val := f, comp := hf }))
(match Opposite.op { obj := B, pt := b, isGalois := isGalois_1 } with
| Opposite.op { obj := A, pt := a, isGalois := isGalois } =>
{ app := fun X f => (CategoryTheory.ConcreteCategory.hom (F.map f)) a, naturality := ⋯ }) =
CategoryTheory.CategoryStruct.comp
(match Opposite.op { obj := A, pt := a, isGalois := isGalois } with
| Opposite.op { obj := A, pt := a, isGalois := isGalois } =>
{ app := fun X f => (CategoryTheory.ConcreteCategory.hom (F.map f)) a, naturality := ⋯ })
(((CategoryTheory.Functor.const (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ).obj
(F.comp FintypeCat.incl)).map
(Opposite.op { val := f, comp := hf })) | false |
_private.Mathlib.Order.CompleteLattice.Basic.0.iSup_lt_iff.match_1_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_2} [inst : CompleteLattice α] {f : ι → α} {a : α}
(motive : (∃ b < a, ∀ (i : ι), f i ≤ b) → Prop) (x : ∃ b < a, ∀ (i : ι), f i ≤ b),
(∀ (w : α) (h : w < a) (hb : ∀ (i : ι), f i ≤ w), motive ⋯) → motive x | false |
Hindman.FS.below.rec | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FS a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FS a a_1) → Hindman.FS.below t → Prop},
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
(∀ (a : Stream' M) (m : M) (h : Hindman.FS a.tail m) (ih : Hindman.FS.below h) (h_ih : motive a.tail m h),
motive_1 h ih → motive_1 ⋯ ⋯) →
(∀ (a : Stream' M) (m : M) (h : Hindman.FS a.tail m) (ih : Hindman.FS.below h) (h_ih : motive a.tail m h),
motive_1 h ih → motive_1 ⋯ ⋯) →
∀ {a : Stream' M} {a_1 : M} {t : Hindman.FS a a_1} (t_1 : Hindman.FS.below t), motive_1 t t_1 | false |
AntivaryOn.eq_1 | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] (f : ι → α) (g : ι → β)
(s : Set ι), AntivaryOn f g s = ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → g i < g j → f j ≤ f i | true |
Matrix.transposeᵣ.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x : ℕ) (x_4 : Matrix (Fin x) (Fin 0) α), x_4.transposeᵣ = Matrix.of ![] | true |
instReprExcept.match_1 | Init.Data.ToString.Basic | {ε : Type u_1} →
{α : Type u_2} →
(motive : Except ε α → ℕ → Sort u_3) →
(x : Except ε α) →
(x_1 : ℕ) →
((e : ε) → (prec : ℕ) → motive (Except.error e) prec) →
((a : α) → (prec : ℕ) → motive (Except.ok a) prec) → motive x x_1 | false |
Similar.exists_pos_dist_eq | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂} [inst : PseudoMetricSpace P₁]
[inst_1 : PseudoMetricSpace P₂],
Similar v₁ v₂ → ∃ r, 0 < r ∧ ∀ (i₁ i₂ : ι), dist (v₁ i₁) (v₁ i₂) = r * dist (v₂ i₁) (v₂ i₂) | true |
MonTypeEquivalenceMon.inverse._proof_9 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (X : MonCat),
CategoryTheory.Mon.Hom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) ⋯ ⋯ =
CategoryTheory.CategoryStruct.id
{ X := ↑X, mon := { one := fun x => 1, mul := fun p => p.1 * p.2, one_mul := ⋯, mul_one := ⋯, mul_assoc := ⋯ } } | false |
CategoryTheory.Bicategory.InducedBicategory.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {P : Sort u} →
{B : Type u_1} →
{C : Type u_2} →
{inst : CategoryTheory.Bicategory C} →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{t : X.Hom Y} →
{B' : Type u_1} →
{C' : Type u_2} →
{inst' : CategoryTheory.Bicategory C'} →
{F' : B' → C'} →
{X' Y' : CategoryTheory.Bicategory.InducedBicategory C' F'} →
{t' : X'.Hom Y'} →
B = B' →
C = C' →
inst ≍ inst' →
F ≍ F' →
X ≍ X' →
Y ≍ Y' →
t ≍ t' → CategoryTheory.Bicategory.InducedBicategory.Hom.noConfusionType P t t' | false |
CategoryTheory.CreatesColimitsOfShape.mk | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{F : CategoryTheory.Functor C D} →
autoParam ({K : CategoryTheory.Functor J C} → CategoryTheory.CreatesColimit K F)
CategoryTheory.CreatesColimitsOfShape.CreatesColimit._autoParam →
CategoryTheory.CreatesColimitsOfShape J F | true |
Asymptotics.IsLittleO.sum_congr | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E' : Type u_6} [inst : SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_18} {A : ι → α → E'}
{s : Finset ι} {B : ι → α → ℝ}, (∀ i ∈ s, A i =o[l] B i) → (fun H => ∑ i ∈ s, A i H) =o[l] fun H => ∑ i ∈ s, ‖B i H‖ | true |
Lean.Elab.Term.MutualClosure.LetRecClosure | Lean.Elab.MutualDef | Type | true |
LinearMap.coprod_inl | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃), f.coprod g ∘ₗ LinearMap.inl R M M₂ = f | true |
Interval.coeHom.match_1 | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(motive : Interval α → Sort u_2) →
(s : Interval α) → (Unit → motive none) → ((s : NonemptyInterval α) → motive (some s)) → motive s | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.WithZero.map'_mono._simp_1_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {p : WithZero α → Prop}, (∀ (x : WithZero α), p x) = (p 0 ∧ ∀ (a : α), p ↑a) | false |
Std.TreeSet.Equiv.of_forall_mem_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
(∀ (k : α), k ∈ t₁ ↔ k ∈ t₂) → t₁.Equiv t₂ | true |
List.Nodup.pairwise_coe | Mathlib.Data.Set.Pairwise.List | ∀ {α : Type u_1} {r : α → α → Prop} {l : List α} [Std.Symm r], l.Nodup → ({a | a ∈ l}.Pairwise r ↔ List.Pairwise r l) | true |
OpenNormalAddSubgroup.instLatticeOfSeparatelyContinuousAdd._proof_2 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] (a b : OpenNormalAddSubgroup G),
SemilatticeInf.inf a b ≤ b | false |
Heyting.Regular.instBooleanAlgebra._proof_9 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (x : Heyting.Regular α), x ⊓ xᶜ ≤ ⊥ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.