name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Nat.lt_of_shiftLeft_lt | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b c : ℕ}, a <<< b < c → a < c | true |
dite_mem | Mathlib.Logic.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Membership α β] {p : Prop} [inst_1 : Decidable p] {a : p → α} {b : ¬p → α}
{s : β}, (if h : p then a h else b h) ∈ s ↔ (∀ (h : p), a h ∈ s) ∧ ∀ (h : ¬p), b h ∈ s | true |
MeasureTheory.Measure.ext_of_sUnion_eq_univ | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {S : Set (Set α)},
S.Countable → ⋃₀ S = Set.univ → (∀ s ∈ S, μ.restrict s = ν.restrict s) → μ = ν | true |
UpperHalfPlane.instNontrivial | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | Nontrivial UpperHalfPlane | true |
CategoryTheory.Limits.reflexiveCoequalizerIsoCoequalizer.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
[inst_1 :
CategoryTheory.Limits.HasCoequalizer (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left)
(F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right)],
CategoryTheory.Limits.reflexiveCoequalizerIsoCoequalizer F =
((CategoryTheory.Limits.ReflexiveCofork.isColimitEquiv F (CategoryTheory.Limits.colimit.cocone F)).symm
(CategoryTheory.Limits.colimit.isColimit F)).coconePointUniqueUpToIso
(CategoryTheory.Limits.colimit.isColimit
(CategoryTheory.Limits.parallelPair (F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.left)
(F.map CategoryTheory.Limits.WalkingReflexivePair.Hom.right))) | true |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_10 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam
(∀ (x : WittVector.StandardOneDimIsocrystal p k _m),
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8 p k _m 0 x = 0)
AddMonoid.nsmul_zero._autoParam | false |
SkewMonoidAlgebra.single_eq_zero | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a : G} {b : k}, SkewMonoidAlgebra.single a b = 0 ↔ b = 0 | true |
_private.Lean.Meta.ProdN.0.Lean.Meta.mkProdN.match_1 | Lean.Meta.ProdN | (motive : MProd (Array Lean.Expr) (MProd Lean.Expr Lean.Level) → Sort u_1) →
(r : MProd (Array Lean.Expr) (MProd Lean.Expr Lean.Level)) →
((ts : Array Lean.Expr) → (tupleTy : Lean.Expr) → (u : Lean.Level) → motive ⟨ts, tupleTy, u⟩) → motive r | false |
Unitization.instMulOneClass._proof_4 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : DistribMulAction R A]
(a : Unitization R A), a * 1 = a | false |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.hall_subgraph._proof_3 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {V : Type u_1} {G : SimpleGraph V} {p : Set V} [inst : DecidablePred fun x => x ∈ p] (f : ↑p → V),
(∀ (x : ↑p), G.Adj (↑x) (f x)) →
∀ {v w : V}, (if h : v ∈ p then f ⟨v, h⟩ = w else if h : w ∈ p then f ⟨w, h⟩ = v else False) → G.Adj v w | false |
Set.encard_insert_le | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α) (x : α), (insert x s).encard ≤ s.encard + 1 | true |
CategoryTheory.GrothendieckTopology.pseudofunctorOver_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj_str_id_hom_app | Mathlib.CategoryTheory.Sites.PseudofunctorSheafOver | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} A] (b : CategoryTheory.LocallyDiscrete Cᵒᵖ)
(X : CategoryTheory.ObjectProperty.FullSubcategory (CategoryTheory.Presheaf.IsSheaf (J.over (Opposite.unop b.as))))
(X_1 : (CategoryTheory.Over (Opposite.unop b.as))ᵒᵖ),
(CategoryTheory.CategoryStruct.id X).hom.app X_1 = CategoryTheory.CategoryStruct.id (X.obj.obj X_1) | true |
UInt16.rec._@.Mathlib.Util.CompileInductive.3197476844._hygCtx._hyg.378 | Mathlib.Util.CompileInductive | {motive : UInt16 → Sort u} → ((toBitVec : BitVec 16) → motive { toBitVec := toBitVec }) → (t : UInt16) → motive t | false |
OrderedFinpartition.eraseLeft | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | {n : ℕ} → (c : OrderedFinpartition (n + 1)) → Set.range (c.emb 0) = {0} → OrderedFinpartition n | true |
groupHomology.isoShortComplexH1._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | (ComplexShape.down ℕ).prev 1 = 2 | false |
Quiver.SingleObj.toPrefunctor_apply_obj | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (a : Quiver.SingleObj α), (Quiver.SingleObj.toPrefunctor f).obj a = id a | true |
SheafOfModules.GeneratingSections.I | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
{M : SheafOfModules R} → M.GeneratingSections → Type u | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_29 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (cache : Std.Tactic.BVDecide.BVExpr.Cache aig) (w n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs_1 : aig_1.RefVec w)
(hlaig : aig.decls.size ≤ { aig := aig_1, vec := lhs_1 }.aig.decls.size)
(cache_1 : Std.Tactic.BVDecide.BVExpr.Cache (↑⟨{ aig := aig_1, vec := lhs_1 }, hlaig⟩).aig),
(invImage
(fun x =>
PSum.casesOn x
(fun _x =>
PSigma.casesOn _x fun w aig =>
PSigma.casesOn aig fun aig expr => PSigma.casesOn expr fun expr cache => (sizeOf expr, 1))
fun _x =>
PSigma.casesOn _x fun w aig =>
PSigma.casesOn aig fun aig expr => PSigma.casesOn expr fun expr cache => (sizeOf expr, 0))
Prod.instWellFoundedRelation).1
(PSum.inl ⟨n, ⟨aig_1, ⟨rhs, cache_1⟩⟩⟩) (PSum.inr ⟨w, ⟨aig, ⟨lhs.shiftLeft rhs, cache⟩⟩⟩) | false |
CategoryTheory.Regular.instMonoDesc | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Regular C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.Limits.coequalizer.desc f ⋯) | true |
List.isPrefixOf_nil_left | Init.Data.List.Basic | ∀ {α : Type u} {l : List α} [inst : BEq α], [].isPrefixOf l = true | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.of.sizeOf_spec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ (η : Mathlib.Tactic.BicategoryLike.HorizontalComp),
sizeOf (Mathlib.Tactic.BicategoryLike.WhiskerLeft.of η) = 1 + sizeOf η | true |
smul_preimage_set_subsetₛₗ | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_3} {α : Type u_4} {β : Type u_5} {σ : M → N} [inst : SMul M α]
[inst_1 : SMul N β] [inst_2 : FunLike F α β] [MulActionSemiHomClass F σ α β] (f : F) (c : M) (t : Set β),
c • ⇑f ⁻¹' t ⊆ ⇑f ⁻¹' (σ c • t) | true |
pathComponent_subset_component | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X), pathComponent x ⊆ connectedComponent x | true |
Lean.Meta.Grind.synthInstance? | Lean.Meta.Tactic.Grind.SynthInstance | Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Expr) | true |
ContinuousMap.instAddCommGroupContinuousMap._proof_5 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddCommGroup β]
[inst_3 : IsTopologicalAddGroup β] (f g : C(α, β)), ⇑(f + g) = ⇑f + ⇑g | false |
CoalgEquiv.toCoalgIso | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
[inst_1 : AddCommGroup X] →
[inst_2 : Module R X] →
[inst_3 : AddCommGroup Y] →
[inst_4 : Module R Y] →
[inst_5 : Coalgebra R X] → [inst_6 : Coalgebra R Y] → (X ≃ₗc[R] Y) → (CoalgCat.of R X ≅ CoalgCat.of R Y) | true |
Std.DTreeMap.Internal.Impl.link._unsafe_rec | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) →
β k →
(l r : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → r.Balanced → Std.DTreeMap.Internal.Impl.Tree α β (l.size + 1 + r.size) | false |
ProbabilityTheory.«term𝔼[_]» | Mathlib.Probability.Notation | Lean.ParserDescr | true |
_private.Mathlib.RingTheory.SimpleModule.WedderburnArtin.0.isSemisimpleRing_iff_pi_matrix_divisionRing.match_1_1 | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ {R : Type u_1} [inst : Ring R]
(motive :
(∃ n D d x, (∀ (i : Fin n), NeZero (d i)) ∧ Nonempty (R ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)))) →
Prop)
(x :
∃ n D d x, (∀ (i : Fin n), NeZero (d i)) ∧ Nonempty (R ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)))),
(∀ (n : ℕ) (D : Fin n → Type u_1) (d : Fin n → ℕ) (w : (i : Fin n) → DivisionRing (D i))
(left : ∀ (i : Fin n), NeZero (d i)) (e : Nonempty (R ≃+* ((i : Fin n) → Matrix (Fin (d i)) (Fin (d i)) (D i)))),
motive ⋯) →
motive x | false |
IsOpen.analyticSet_image | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_3} [inst_1 : TopologicalSpace β] [PolishSpace β] {s : Set β},
IsOpen s → ∀ {f : β → α}, Continuous f → MeasureTheory.AnalyticSet (f '' s) | true |
AlgebraicTopology.DoldKan.N₁Γ₀_app | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ),
AlgebraicTopology.DoldKan.N₁Γ₀.app K =
(AlgebraicTopology.DoldKan.Γ₀.splitting K).toKaroubiNondegComplexIsoN₁.symm ≪≫
(CategoryTheory.Idempotents.toKaroubi (ChainComplex C ℕ)).mapIso (AlgebraicTopology.DoldKan.Γ₀NondegComplexIso K) | true |
Subalgebra.copy_eq | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
(s : Set A) (hs : s = ↑S), S.copy s hs = S | true |
AntisymmRel.not_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} {a b : α} {r : α → α → Prop}, AntisymmRel r a b → ¬IncompRel r a b | true |
_private.Mathlib.Algebra.Ring.Int.Parity.0.Int.even_xor'_odd'._proof_1_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ (k : ℤ), Xor' (k + k = 2 * k) (k + k = 2 * k + 1) | false |
Std.PRange.instToStreamRiiIterIteratorOfUpwardEnumerableOfLeast? | Init.Data.Range.Polymorphic.Stream | {α : Type} → [Std.PRange.UpwardEnumerable α] → [Std.PRange.Least? α] → Std.ToStream (Std.Rii α) (Std.Iter α) | true |
IO.TaskState.noConfusionType | Init.System.IO | Sort v✝ → IO.TaskState → IO.TaskState → Sort v✝ | true |
closedPoints | Mathlib.Topology.JacobsonSpace | (X : Type u_1) → [TopologicalSpace X] → Set X | true |
Lean.Grind.Field.NormNum.inv_eq | Init.Grind.FieldNormNum | ∀ {α : Type u_1} [inst : Lean.Grind.Field α] (a : α) (v₁ v : ℚ),
(v == v₁⁻¹) = true → a = Lean.Grind.Field.NormNum.ofRat v₁ → a⁻¹ = Lean.Grind.Field.NormNum.ofRat v | true |
nhds_zero_symm' | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type w) [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G],
Filter.map Neg.neg (nhds 0) = nhds 0 | true |
Lean.Parser.Term.match._regBuiltin.Lean.Parser.Term.generalizingParam.parenthesizer_47 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.solve.match_1 | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
(α : Q(Type u)) →
(e : Q(«$α»)) →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(motive : Mathlib.Meta.Positivity.OrderRel✝ → Mathlib.Meta.Positivity.Strictness zα pα e → Sort u_1) →
(relDesired : Mathlib.Meta.Positivity.OrderRel✝¹) →
(r : Mathlib.Meta.Positivity.Strictness zα pα e) →
((p : Q(0 < «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.lt✝ (Mathlib.Meta.Positivity.Strictness.positive p)) →
((p : Q(0 ≤ «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.le✝ (Mathlib.Meta.Positivity.Strictness.nonnegative p)) →
((p : Q(«$e» ≠ 0)) →
motive Mathlib.Meta.Positivity.OrderRel.ne✝ (Mathlib.Meta.Positivity.Strictness.nonzero p)) →
((p : Q(0 < «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.le✝¹
(Mathlib.Meta.Positivity.Strictness.positive p)) →
((p : Q(0 < «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.ne✝¹
(Mathlib.Meta.Positivity.Strictness.positive p)) →
((p : Q(0 < «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.ne'✝
(Mathlib.Meta.Positivity.Strictness.positive p)) →
((p : Q(«$e» ≠ 0)) →
motive Mathlib.Meta.Positivity.OrderRel.ne'✝¹
(Mathlib.Meta.Positivity.Strictness.nonzero p)) →
((pf : Q(0 ≤ «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.lt✝¹
(Mathlib.Meta.Positivity.Strictness.nonnegative pf)) →
((pf : Q(«$e» ≠ 0)) →
motive Mathlib.Meta.Positivity.OrderRel.lt✝²
(Mathlib.Meta.Positivity.Strictness.nonzero pf)) →
((pf : Q(«$e» ≠ 0)) →
motive Mathlib.Meta.Positivity.OrderRel.le✝²
(Mathlib.Meta.Positivity.Strictness.nonzero pf)) →
((pf : Q(0 ≤ «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.ne✝²
(Mathlib.Meta.Positivity.Strictness.nonnegative pf)) →
((pf : Q(0 ≤ «$e»)) →
motive Mathlib.Meta.Positivity.OrderRel.ne'✝²
(Mathlib.Meta.Positivity.Strictness.nonnegative pf)) →
((x : Mathlib.Meta.Positivity.OrderRel✝²) →
motive x Mathlib.Meta.Positivity.Strictness.none) →
motive relDesired r | false |
List.dropLast_cons₂ | Init.Data.List.Basic | ∀ {α : Type u_1} {x y : α} {zs : List α}, (x :: y :: zs).dropLast = x :: (y :: zs).dropLast | true |
_private.Mathlib.Combinatorics.Derangements.Finite.0.card_derangements_fin_eq_numDerangements._proof_1_2 | Mathlib.Combinatorics.Derangements.Finite | ∀ (n : ℕ), n < n + 1 + 1 | false |
AddSubmonoid.LocalizationMap.of_addEquivOfAddEquiv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {T : AddSubmonoid P} {Q : Type u_4} [inst_3 : AddCommMonoid Q]
{k : T.LocalizationMap Q} {j : M ≃+ P} (H : AddSubmonoid.map j.toAddMonoidHom S = T),
(f.ofAddEquivOfLocalizations (f.addEquivOfAddEquiv k H)).toAddMonoidHom = k.toAddMonoidHom.comp j.toAddMonoidHom | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.nontrivial_prod_iff._simp_1_2 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α}, s.Nontrivial = (1 < s.card) | false |
LieAdmissibleAlgebra.noConfusionType | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | Sort u →
{R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieAdmissibleRing L] →
LieAdmissibleAlgebra R L →
{R' : Type u_1} →
{L' : Type u_2} →
[inst' : CommRing R'] → [inst'_1 : LieAdmissibleRing L'] → LieAdmissibleAlgebra R' L' → Sort u | false |
one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), 1 /ₚ u = ↑u⁻¹ | true |
unitInterval.image_coe_preimage_symm | Mathlib.Topology.UnitInterval | ∀ {s : Set ↑unitInterval}, Subtype.val '' (unitInterval.symm ⁻¹' s) = (fun x => 1 - x) ⁻¹' (Subtype.val '' s) | true |
CategoryTheory.StructuredArrow.mapIso_unitIso_inv_app_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S S' : D} {T : CategoryTheory.Functor C D} (i : S ≅ S')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T),
((CategoryTheory.StructuredArrow.mapIso i).unitIso.inv.app X).right = CategoryTheory.CategoryStruct.id X.right | true |
Ordnode.foldr._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → {β : Sort u_2} → (α → β → β) → Ordnode α → β → β | false |
Lean.Doc.set_option._regBuiltin.Lean.Doc.set_option.getArgs.declRange_7 | Lean.Elab.DocString.Builtin | IO Unit | false |
Algebra.pushoutDesc_left | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
(S' : Type u_7) [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' S'] [inst_10 : IsScalarTower R S S']
[inst_11 : Algebra.IsPushout R S R' S'] {A : Type u_8} [inst_12 : Semiring A] [inst_13 : Algebra R A] (f : S →ₐ[R] A)
(g : R' →ₐ[R] A) (H : ∀ (x : S) (y : R'), f x * g y = g y * f x) (x : S),
(Algebra.pushoutDesc S' f g H) ((algebraMap S S') x) = f x | true |
CategoryTheory.ObjectProperty.prop_iSup_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.CompleteLattice | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Sort u_1} (P : α → CategoryTheory.ObjectProperty C)
(X : C), (⨆ a, P a) X = ∃ a, P a X | false |
Orientation.basisRightAngleRotation | Mathlib.Analysis.InnerProductSpace.TwoDim | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : InnerProductSpace ℝ E] →
[Fact (Module.finrank ℝ E = 2)] → Orientation ℝ E (Fin 2) → (x : E) → x ≠ 0 → Module.Basis (Fin 2) ℝ E | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(f : R) →
LocalizedModule (Submonoid.powers f) M →ₗ[R]
(AlgebraicGeometry.structureSheafInType R M).obj.obj (Opposite.op (PrimeSpectrum.basicOpen f)) | true |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.type_eq_one_iff_unique.match_1_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u_1} (motive : Nonempty (Unique α) → Prop) (x : Nonempty (Unique α)),
(∀ (val : Unique α), motive ⋯) → motive x | false |
IsometryEquiv.instEquivLike | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} → {β : Type v} → [inst : PseudoEMetricSpace α] → [inst_1 : PseudoEMetricSpace β] → EquivLike (α ≃ᵢ β) α β | true |
isAtomistic_dual_iff_isCoatomistic._simp_1 | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderTop α], IsAtomistic αᵒᵈ = IsCoatomistic α | false |
_private.Lean.Compiler.IR.ExpandResetReuse.0.Lean.IR.ExpandResetReuse.searchAndExpand._sparseCasesOn_1 | Lean.Compiler.IR.ExpandResetReuse | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
((n : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.reset n x)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
WithTop.lt_iff_exists_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] {x y : WithTop α}, y < x ↔ ∃ b, y = ↑b ∧ ↑b < x | true |
List.subset_cons_of_subset._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, l₁ ⊆ l₂ → (l₁ ⊆ a :: l₂) = True | false |
PNat.XgcdType.vp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ × ℕ | true |
Filter.map_sumElim_eq | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (l : Filter (α ⊕ β)) (m₁ : α → γ) (m₂ : β → γ),
Filter.map (Sum.elim m₁ m₂) l = Filter.map m₁ (Filter.comap Sum.inl l) ⊔ Filter.map m₂ (Filter.comap Sum.inr l) | true |
ArchimedeanClass.mk_neg | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a : M),
ArchimedeanClass.mk (-a) = ArchimedeanClass.mk a | true |
_private.Mathlib.Combinatorics.SimpleGraph.Hall.0.SimpleGraph.exists_bijective_of_forall_ncard_le._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Hall | ∀ {V : Type u_1} {p₁ p₂ : Set V} (f : V → V),
(∀ x ∈ p₁, f x ∉ p₁) → (∀ (x : V), f x ∈ p₁ ∨ f x ∈ p₂) → ∀ (x : ↑p₁), f ↑x ∈ p₂ | false |
Lean.Compiler.LCNF.Specialize.findSpecCache? | Lean.Compiler.LCNF.Specialize | Lean.Expr → Lean.CoreM (Option Lean.Name) | true |
Matroid.restrict_eq_self_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {R : Set α}, (M.restrict R = M) = (R = M.E) | false |
Std.DTreeMap.Internal.Impl.insertMany_cons | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} (h : t.WF)
{l : List ((a : α) × β a)} {k : α} {v : β k},
↑(t.insertMany (⟨k, v⟩ :: l) ⋯) = ↑((Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.insertMany l ⋯) | true |
Lean.Doc.Data.inst._@.Lean.Elab.DocString.Builtin.1563348410._hygCtx._hyg.8 | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.Tactic | false |
Std.HashSet.Raw.ofArray | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → Array α → Std.HashSet.Raw α | true |
Stream'.WSeq.get?_congr | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {s t : Stream'.WSeq α}, s ~ʷ t → ∀ (n : ℕ), (s.get? n).Equiv (t.get? n) | true |
IsBaseChange.of_lift_unique | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {M : Type v₁} {N : Type v₂} {S : Type v₃} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
[inst_2 : CommSemiring R] [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module R N]
[inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (f : M →ₗ[R] N),
(∀ (Q : Type (max v₁ v₂ v₃)) [inst_9 : AddCommMonoid Q] [inst_10 : Module R Q] [inst_11 : Module S Q]
[inst_12 : IsScalarTower R S Q] (g : M →ₗ[R] Q), ∃! g', ↑R g' ∘ₗ f = g) →
IsBaseChange S f | true |
FirstOrder.Language.IsFraisseLimit.recOn | Mathlib.ModelTheory.Fraisse | {L : FirstOrder.Language} →
{K : Set (CategoryTheory.Bundled L.Structure)} →
{M : Type w} →
[inst : L.Structure M] →
[inst_1 : Countable ((l : ℕ) × L.Functions l)] →
[inst_2 : Countable M] →
{motive : FirstOrder.Language.IsFraisseLimit K M → Sort u_1} →
(t : FirstOrder.Language.IsFraisseLimit K M) →
((ultrahomogeneous : L.IsUltrahomogeneous M) → (age : L.age M = K) → motive ⋯) → motive t | false |
_private.Init.Data.Vector.Extract.0.Vector.extract_push._proof_3 | Init.Data.Vector.Extract | ∀ {n start stop : ℕ}, ¬stop ≤ n → start ≤ n → ¬min n n - start + 1 = min stop (n + 1) - start → False | false |
Ordinal.dvd_antisymm | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b : Ordinal.{u_4}}, a ∣ b → b ∣ a → a = b | true |
CategoryTheory.HasShift | Mathlib.CategoryTheory.Shift.Basic | (C : Type u) → (A : Type u_2) → [CategoryTheory.Category.{v, u} C] → [AddMonoid A] → Type (max (max u u_2) v) | true |
_private.Mathlib.Order.Zorn.0.zorn_le₀.match_1_5 | Mathlib.Order.Zorn | ∀ {α : Type u_1} [inst : Preorder α] (s : Set α) (c : Set ↑s)
(motive : (∃ ub ∈ s, ∀ z ∈ Subtype.val '' c, z ≤ ub) → Prop) (x : ∃ ub ∈ s, ∀ z ∈ Subtype.val '' c, z ≤ ub),
(∀ (ub : α) (hubs : ub ∈ s) (hub : ∀ z ∈ Subtype.val '' c, z ≤ ub), motive ⋯) → motive x | false |
_private.Mathlib.Algebra.Ring.Subring.Basic.0.Subring.top_prod._simp_1_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {s : Subring R} {t : Subring S}
{p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
_private.Mathlib.Data.Int.Basic.0.Int.inductionOn'.match_1.eq_1 | Mathlib.Data.Int.Basic | ∀ (motive : ℤ → Sort u_1) (n : ℕ) (h_1 : (n : ℕ) → motive (Int.ofNat n)) (h_2 : (n : ℕ) → motive (Int.negSucc n)),
(match Int.ofNat n with
| Int.ofNat n => h_1 n
| Int.negSucc n => h_2 n) =
h_1 n | true |
uniformity_edist | Mathlib.Topology.EMetricSpace.Defs | ∀ {γ : Type w} [inst : EMetricSpace γ], uniformity γ = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | true |
Nat.sum_trichotomy.match_1 | Batteries.Data.Nat.Lemmas | (motive : Ordering → Sort u_1) →
(x : Ordering) →
(x = Ordering.lt → motive Ordering.lt) →
(x = Ordering.eq → motive Ordering.eq) → (x = Ordering.gt → motive Ordering.gt) → motive x | false |
ProbabilityTheory.measurableSet_partitionFiltration_of_mem | Mathlib.Probability.Process.PartitionFiltration | ∀ {α : Type u_1} [m : MeasurableSpace α] {t : ℕ → Set α} (ht : ∀ (n : ℕ), MeasurableSet (t n)) (n : ℕ) {s : Set α},
s ∈ memPartition t n → MeasurableSet s | true |
List.min_map._proof_1 | Init.Data.List.MinMaxOn | ∀ {β : Type u_1} {α : Type u_2} {xs : List α} {f : α → β}, xs ≠ [] → List.map f xs ≠ [] | false |
Algebra.ker_algebraMap_isMaximal_of_isIntegral | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ (R : Type u_6) [inst : CommRing R] (k : Type u_8) [inst_1 : Field k] [inst_2 : Algebra R k] [Algebra.IsIntegral R k],
(RingHom.ker (algebraMap R k)).IsMaximal | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr.congr_simp | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} {T₁ T₂ : AlgebraicGeometry.Scheme.Pullback.Triplet f g}
(e : T₁ = T₂),
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e = AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_2 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size),
table[table.size - 1] ≤ table.size - 1 → ¬table[table.size - 1] < table.size → False | false |
Lean.Expr.forallName | Lean.Expr | (a : Lean.Expr) → a.isForall = true → Lean.Name | true |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.mor_eq._auto_3 | Mathlib.CategoryTheory.Sites.Descent.Precoverage | Lean.Syntax | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.match_19.eq_1 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (lhs rhs : Std.Sat.AIG.Fanin)
(this : lhs.gate < upper ∧ rhs.gate < upper) (lstate : Std.Sat.AIG.toCNF.State✝ aig)
(motive : { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ lstate out rhs.gate ⋯ } → Sort u_1)
(rstate : Std.Sat.AIG.toCNF.State✝¹ aig) (hrstate : Std.Sat.AIG.toCNF.State.IsExtensionBy✝¹ lstate rstate rhs.gate ⋯)
(h_1 :
(rstate : Std.Sat.AIG.toCNF.State✝² aig) →
(hrstate : Std.Sat.AIG.toCNF.State.IsExtensionBy✝² lstate rstate rhs.gate ⋯) → motive ⟨rstate, hrstate⟩),
(match ⟨rstate, hrstate⟩ with
| ⟨rstate, hrstate⟩ => h_1 rstate hrstate) =
h_1 rstate hrstate | true |
_private.Mathlib.Analysis.Calculus.SmoothSeries.0.contDiff_tsum_of_eventually._simp_1_5 | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Projectivization.Subspace.mem_span | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S : Set (Projectivization K V)} (u : Projectivization K V),
u ∈ Projectivization.Subspace.span S ↔ ∀ (W : Projectivization.Subspace K V), S ⊆ ↑W → u ∈ W | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_475 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
Lean.Elab.Tactic.Conv.evalExtractLets._regBuiltin.Lean.Elab.Tactic.Conv.evalExtractLets_1 | Lean.Elab.Tactic.Conv.Lets | IO Unit | false |
_private.Batteries.Data.List.Basic.0.List.rotate'.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → ℕ → Sort u_2) (l : List α) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (l : List α) → motive l 0) (h_3 : (a : α) → (l : List α) → (n : ℕ) → motive (a :: l) n.succ),
(l = [] → False) →
(match l, 0 with
| [], x => h_1 x
| l, 0 => h_2 l
| a :: l, n.succ => h_3 a l n) =
h_2 l | true |
_private.Std.Data.Iterators.Producers.Monadic.Array.0.Std.Iterators.Types.ArrayIterator.instFinitenessRelation | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} →
{m : Type w → Type w'} → [inst : Pure m] → Std.Iterators.FinitenessRelation (Std.Iterators.Types.ArrayIterator α) m | true |
_aux_Init_Notation___unexpand_HMul_hMul_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | false |
AbsoluteValue.Completion.extensionEmbedding_of_comp._proof_3 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {L : Type u_1} [inst : NormedField L], IsUniformAddGroup L | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic.0.SimplexCategoryGenRel.δ_comp_δ_nat._proof_3 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ}, ∀ i < n + 2, i < n + 1 + 2 | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_inter_right._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 |
MeasurableEmbedding.equivRange._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_2} {β : Type u_1} {f : α → β}, ↑(f '' Set.univ) = ↑(Set.range f) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.