name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete_iff | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l l' : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
l' ∈ (c.delete l).toList ↔ l' ≠ l ∧ l' ∈ c.toList | true |
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.liftAux | Mathlib.FieldTheory.IsAlgClosed.Basic | (K : Type u) →
[inst : Field K] →
(L : Type v) →
(M : Type w) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[inst_3 : Field M] → [inst_4 : Algebra K M] → [IsAlgClosed M] → [Algebra.IsAlgebraic K L] → L →ₐ[K] M | true |
_private.Mathlib.GroupTheory.Subgroup.Centralizer.0.Subgroup.normalizerMonoidHom_ker._simp_1_6 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b) | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.Reorder.reverse._proof_2 | Mathlib.Tactic.Translate.Reorder | ∀ (x : { l // 2 ≤ l.length }), 2 ≤ (↑x).reverse.length | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isSyntheticMVar.match_1 | Lean.Meta.Basic | (motive : Lean.MetavarKind → Sort u_1) →
(__do_lift : Lean.MetavarKind) →
(Unit → motive Lean.MetavarKind.synthetic) →
(Unit → motive Lean.MetavarKind.syntheticOpaque) → ((x : Lean.MetavarKind) → motive x) → motive __do_lift | false |
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuousMap_continuous_integral | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x) | true |
CategoryTheory.Pseudofunctor.DescentData.toDescentDataCompPullFunctorIso | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{S' : C} →
{p : S' ⟶ S} →
{ι' : Type t'} →
{X' : ι' → C} →
{f' : (j : ι') → X' j ⟶ S'} →
{α : ι' → ι} →
{p' : (j : ι') → X' j ⟶ X (α j)} →
(w :
∀ (j : ι'),
CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) =
CategoryTheory.CategoryStruct.comp (f' j) p) →
(F.toDescentData f).comp (CategoryTheory.Pseudofunctor.DescentData.pullFunctor F w) ≅
(F.map p.op.toLoc).toFunctor.comp (F.toDescentData f') | true |
Metric.frontier_thickening_disjoint | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (A : Set α),
Pairwise (Function.onFun Disjoint fun r => frontier (Metric.thickening r A)) | true |
Lean.Elab.Term.MatchExpr.ElseAlt.mk.sizeOf_spec | Lean.Elab.MatchExpr | ∀ (rhs : Lean.Syntax), sizeOf { rhs := rhs } = 1 + sizeOf rhs | true |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatDescFactorial._proof_2 | Mathlib.Tactic.NormNum.NatFactorial | ∀ (x y z : Q(ℕ)), «$x» =Q «$z» + «$y» | false |
denselyOrdered_multiplicative_iff | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {X : Type u_2} [inst : LT X], DenselyOrdered (Multiplicative X) ↔ DenselyOrdered X | true |
Lean.Lsp.SemanticTokenType.method.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.method = 1 | true |
RatFunc.valuation_isEquiv_adic_of_valuation_X_le_one | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [v.IsRankOneDiscrete] [Valuation.IsTrivialOn K v],
v RatFunc.X ≤ 1 → ∃ u, v.IsEquiv (IsDedekindDomain.HeightOneSpectrum.valuation (RatFunc K) u) | true |
GrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} GrpCat.uliftFunctor | true |
MeasureTheory.regular_inv_iff | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G], μ.inv.Regular ↔ μ.Regular | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter.match_3.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ (motive : Ordering → Sort u_1) (h_1 : Ordering.eq = Ordering.lt → motive Ordering.lt)
(h_2 : Ordering.eq = Ordering.gt → motive Ordering.gt) (h_3 : Ordering.eq = Ordering.eq → motive Ordering.eq),
(match h : Ordering.eq with
| Ordering.lt => h_1 h
| Ordering.gt => h_2 h
| Ordering.eq => h_3 h) =
h_3 ⋯ | true |
ULift.semiring._proof_5 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Semiring R] (x : ULift.{u_1, u_2} R), Monoid.npow 0 x = 1 | false |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.nonempty_algHom_adjoin_of_splits.match_1_1 | Mathlib.FieldTheory.Extension | ∀ {F : Type u_3} {E : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] {S : Set E}
(motive : (∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb) → Prop)
(x : ∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb),
(∀ (φ : ↥(IntermediateField.adjoin F S) →ₐ[F] K) (h : φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb), motive ⋯) →
motive x | false |
CategoryTheory.Limits.CatCospanTransform.inv_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
[inst_6 : CategoryTheory.Category.{v₇, u₇} A''] [inst_7 : CategoryTheory.Category.{v₈, u₈} B'']
[inst_8 : CategoryTheory.Category.{v₉, u₉} C''] {F'' : CategoryTheory.Functor A'' B''}
{G'' : CategoryTheory.Functor C'' B''} {ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'} (η : ψ ⟶ ψ')
[inst_9 : CategoryTheory.IsIso η] {φ : CategoryTheory.Limits.CatCospanTransform F' G' F'' G''},
CategoryTheory.inv (CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight η φ) =
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight (CategoryTheory.inv η) φ | true |
EReal.abs_neg | Mathlib.Data.EReal.Inv | ∀ (x : EReal), (-x).abs = x.abs | true |
Mathlib.Tactic.Ring.ExProd.cast._unsafe_rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
{a : Q(«$α»)} → Mathlib.Tactic.Ring.ExProd sα a → (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExProd sβ a | false |
Std.DHashMap.Raw.get!_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α} [inst_3 : Inhabited (β k)], k ∈ m₂ → (m₁ ∩ m₂).get! k = m₁.get! k | true |
NumberField.mixedEmbedding.convexBodySum.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B B_1 : ℝ),
B = B_1 →
∀ (a a_1 : NumberField.mixedEmbedding.mixedSpace K),
a = a_1 → NumberField.mixedEmbedding.convexBodySum K B a = NumberField.mixedEmbedding.convexBodySum K B_1 a_1 | true |
AntivaryOn.neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn f g s → MonovaryOn (-f) g s | true |
_private.Lean.Elab.Tactic.Change.0.Lean.Elab.Tactic.evalChange.match_1 | Lean.Elab.Tactic.Change | (motive : Lean.Expr × List Lean.MVarId → Sort u_1) →
(__discr : Lean.Expr × List Lean.MVarId) →
((hTy' : Lean.Expr) → (mvars : List Lean.MVarId) → motive (hTy', mvars)) → motive __discr | false |
Lean.Parser.Term.debugAssert._regBuiltin.Lean.Parser.Term.debugAssert.parenthesizer_11 | Lean.Parser.Term | IO Unit | false |
GrpCat.limitGroup._proof_3 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J GrpCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget GrpCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget GrpCat))).pt),
a * b * c = a * (b * c) | false |
Ideal.IsHomogeneous.iSup₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} {f : (i : κ) → κ' i → Ideal A},
(∀ (i : κ) (j : κ' i), Ideal.IsHomogeneous 𝒜 (f i j)) → Ideal.IsHomogeneous 𝒜 (⨆ i, ⨆ j, f i j) | true |
List.max?.eq_1 | Init.Data.List.MinMax | ∀ {α : Type u} [inst : Max α], [].max? = none | true |
Equiv.Perm.toList_ne_singleton | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : Equiv.Perm α) (x y : α), p.toList x ≠ [y] | true |
CategoryTheory.Limits.IsZero.iso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X),
CategoryTheory.CategoryStruct.comp (hX.to_ Y) (hX.from_ Y) = CategoryTheory.CategoryStruct.id X | false |
LowerSet.instDiv._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α] (s t : LowerSet α),
IsLowerSet (s.carrier / ↑t) | false |
_private.Mathlib.Algebra.Free.0.FreeMagma.length_pos.match_1_1 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeMagma α → Prop) (x : FreeMagma α),
(∀ (a : α), motive (FreeMagma.of a)) → (∀ (y z : FreeMagma α), motive (y.mul z)) → motive x | false |
CategoryTheory.Limits.pullbackConeOfLeftIso_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).fst = CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | true |
Membership.mem.out | Mathlib.Data.Set.Operations | ∀ {α : Type u} {a : α} {p : α → Prop}, a ∈ {x | p x} → p a | true |
QuotientAddGroup.lift._proof_2 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_2} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M), N ≤ φ.ker → QuotientAddGroup.con N ≤ AddCon.ker φ | false |
SignType.ofNat | Mathlib.Data.Sign.Defs | ℕ → SignType | true |
Filter.Germ.instSemigroup._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : Semigroup M] (a b c : l.Germ M), a * b * c = a * (b * c) | false |
Int.mul_tmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).tmod b = 0 | true |
Lean.Lsp.ReferenceContext.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ReferenceContext → Sort u} →
((includeDeclaration : Bool) → motive { includeDeclaration := includeDeclaration }) →
(t : Lean.Lsp.ReferenceContext) → motive t | false |
Mathlib.Meta.Positivity.evalFinsetSum | Mathlib.Tactic.Positivity.Finset | Mathlib.Meta.Positivity.PositivityExt | true |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.le_offset._proof_1_1 | Init.Grind.Offset | ∀ (a k : ℕ), ¬k ≤ a + k → False | false |
CategoryTheory.CommGrp.forget₂Grp_obj_one | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
CategoryTheory.MonObj.one = CategoryTheory.MonObj.one | true |
FiniteField.instFieldExtension._proof_22 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] (n : ℕ) [inst_2 : CharP k p]
(a : FiniteField.Extension k p n), 1 * a = a | false |
AffineBasis.tot | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P), affineSpan k (Set.range ⇑b) = ⊤ | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | false |
AddCommGrpCat.forget_commGrp_preserves_epi | Mathlib.Algebra.Category.Grp.EpiMono | (CategoryTheory.forget AddCommGrpCat).PreservesEpimorphisms | true |
IsAdicComplete.toIsPrecomplete | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} {inst : CommRing R} {I : Ideal R} {M : Type u_4} {inst_1 : AddCommGroup M} {inst_2 : Module R M}
[self : IsAdicComplete I M], IsPrecomplete I M | true |
CategoryTheory.RegularMono._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {X Y : C} → {f : X ⟶ Y} → [SizeOf C] → CategoryTheory.RegularMono f → ℕ | false |
FirstOrder.Language.PartialEquiv.mk.inj | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} {inst : L.Structure M} {inst_1 : L.Structure N}
{dom : L.Substructure M} {cod : L.Substructure N} {toEquiv : L.Equiv ↥dom ↥cod} {dom_1 : L.Substructure M}
{cod_1 : L.Substructure N} {toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1},
{ dom := dom, cod := cod, toEquiv := toEquiv } = { dom := dom_1, cod := cod_1, toEquiv := toEquiv_1 } →
dom = dom_1 ∧ cod = cod_1 ∧ toEquiv ≍ toEquiv_1 | true |
Condensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))) →
FintypeCat.toProfinite.op.comp
(Condensed.locallyConstantPresheaf
(F.obj (FintypeCat.toProfinite.op.obj (Opposite.op (FintypeCat.of PUnit.{u + 1}))))) ≅
Condensed.finYoneda F | true |
CategoryTheory.Limits.Concrete.initial_of_empty_of_reflects | Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC]
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Functor.empty C) (CategoryTheory.forget C)] (X : C),
IsEmpty (CategoryTheory.ToType X) → Nonempty (CategoryTheory.Limits.IsInitial X) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.IsCycles.other_adj_of_adj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u} (G : SimpleGraph V) (v w : V), G.Adj v w = (w ∈ G.neighborSet v) | false |
AddCommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : AddCommGroup α] [inst_2 : AddLeftMono α],
AddCommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | true |
Aesop.instInhabitedMVarClusterData.default | Aesop.Tree.Data | {a a_1 : Type} → Aesop.MVarClusterData a a_1 | true |
Lean.Elab.Term.SyntheticMVarKind.typeClass.inj | Lean.Elab.Term.TermElabM | ∀ {extraErrorMsg? extraErrorMsg?_1 : Option Lean.MessageData},
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg? =
Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?_1 →
extraErrorMsg? = extraErrorMsg?_1 | true |
Lean.PrefixTreeNode.below_2 | Lean.Data.PrefixTree | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1} →
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1} →
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) → Sort u_1} →
Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp →
Sort (max (max (u + 1) ((max u v) + 1)) u_1) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Mathlib.Notation3.MatchState.noConfusion | Mathlib.Util.Notation3 | {P : Sort u} → {t t' : Mathlib.Notation3.MatchState} → t = t' → Mathlib.Notation3.MatchState.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Polynomial.Degree.Units.0.Polynomial.isUnit_iff.match_1_1 | Mathlib.Algebra.Polynomial.Degree.Units | ∀ {R : Type u_1} [inst : Semiring R] {p : Polynomial R} (motive : (∃ r, IsUnit r ∧ Polynomial.C r = p) → Prop)
(x : ∃ r, IsUnit r ∧ Polynomial.C r = p), (∀ (w : R) (hr : IsUnit w) (hrp : Polynomial.C w = p), motive ⋯) → motive x | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.DeprecationInfo.mk.noConfusion | Mathlib.Tactic.Linter.FindDeprecations | {P : Sort u} →
{module decl : Lean.Name} →
{rgStart rgStop : Lean.Position} →
{since : String} →
{module' decl' : Lean.Name} →
{rgStart' rgStop' : Lean.Position} →
{since' : String} →
{ module := module, decl := decl, rgStart := rgStart, rgStop := rgStop, since := since } =
{ module := module', decl := decl', rgStart := rgStart', rgStop := rgStop', since := since' } →
(module = module' → decl = decl' → rgStart = rgStart' → rgStop = rgStop' → since = since' → P) → P | false |
CategoryTheory.Functor.IsRepresentedBy.representableBy | Mathlib.CategoryTheory.RepresentedBy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} →
{X : C} → {x : F.obj (Opposite.op X)} → F.IsRepresentedBy x → F.RepresentableBy X | true |
integrable_cexp_quadratic' | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ},
b.re < 0 → ∀ (c d : ℂ), MeasureTheory.Integrable (fun x => Complex.exp (b * ↑x ^ 2 + c * ↑x + d)) MeasureTheory.volume | true |
Ordinal.IsFundamentalSeq.id | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {o : Ordinal.{u_1}}, o ≤ o.cof.ord → Ordinal.IsFundamentalSeq id | true |
Lean.Doc.Inline.emph.injEq | Lean.DocString.Types | ∀ {i : Type u} (content content_1 : Array (Lean.Doc.Inline i)),
(Lean.Doc.Inline.emph content = Lean.Doc.Inline.emph content_1) = (content = content_1) | true |
CategoryTheory.Functor.toPrefunctor | Mathlib.CategoryTheory.Functor.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → C ⥤q D | true |
Lean.Meta.saveState | Lean.Meta.Basic | Lean.MetaM Lean.Meta.SavedState | true |
AffineSubspace.map_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂), AffineSubspace.map f ⊥ = ⊥ | true |
Lean.Constructor.mk.injEq | Lean.Declaration | ∀ (name : Lean.Name) (type : Lean.Expr) (name_1 : Lean.Name) (type_1 : Lean.Expr),
({ name := name, type := type } = { name := name_1, type := type_1 }) = (name = name_1 ∧ type = type_1) | true |
Filter.eventually_bind._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → Filter β} {p : β → Prop},
(∀ᶠ (y : β) in f.bind m, p y) = ∀ᶠ (x : α) in f, ∀ᶠ (y : β) in m x, p y | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.step_flattenAfter.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m (Std.IterM m β)]
{it₁ : Std.IterM m (Std.IterM m β)} (motive : it₁.Step → Sort u_3) (it₁' : Std.IterM m (Std.IterM m β))
(it₂' : Std.IterM m β) (h : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂'))
(h_1 :
(it₁' : Std.IterM m (Std.IterM m β)) →
(it₂' : Std.IterM m β) →
(h : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂')) → motive ⟨Std.IterStep.yield it₁' it₂', h⟩)
(h_2 :
(it₁' : Std.IterM m (Std.IterM m β)) →
(h : it₁.IsPlausibleStep (Std.IterStep.skip it₁')) → motive ⟨Std.IterStep.skip it₁', h⟩)
(h_3 : (h : it₁.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩),
(match ⟨Std.IterStep.yield it₁' it₂', h⟩ with
| ⟨Std.IterStep.yield it₁' it₂', h⟩ => h_1 it₁' it₂' h
| ⟨Std.IterStep.skip it₁', h⟩ => h_2 it₁' h
| ⟨Std.IterStep.done, h⟩ => h_3 h) =
h_1 it₁' it₂' h | true |
Irrational.of_mul_ratCast | Mathlib.NumberTheory.Real.Irrational | ∀ (q : ℚ) {x : ℝ}, Irrational (x * ↑q) → Irrational x | true |
Set.Finite.cast_ncard_eq | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Finite → ↑s.ncard = s.encard | true |
LinearMap.transvection.comp_of_left_eq | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid V] [inst_2 : Module R V]
{f : Module.Dual R V} {v w : V},
f w = 0 → LinearMap.transvection f v ∘ₗ LinearMap.transvection f w = LinearMap.transvection f (v + w) | true |
AlgebraicGeometry.instIsLocallyArtinianFiberOfLocallyQuasiFinite | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyQuasiFinite f] (y : ↥Y),
AlgebraicGeometry.IsLocallyArtinian (AlgebraicGeometry.Scheme.Hom.fiber f y) | true |
ENNReal.mul_eq_left | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a ≠ 0 → a ≠ ⊤ → (a * b = a ↔ b = 1) | true |
Equiv.piOptionEquivProd_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_10} {β : Option α → Type u_9} (f : (a : Option α) → β a),
Equiv.piOptionEquivProd f = (f none, fun a => f (some a)) | true |
MeasureTheory.ae_eq_comp | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {δ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {f : α → β} {g g' : β → δ},
AEMeasurable f μ → g =ᵐ[MeasureTheory.Measure.map f μ] g' → g ∘ f =ᵐ[μ] g' ∘ f | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic.0.isCyclic_iff_exists_orderOf_eq_natCard._simp_1_2 | Mathlib.GroupTheory.SpecificGroups.Cyclic.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [Finite ↥H], (H = ⊤) = (Nat.card ↥H = Nat.card G) | false |
ByteArray.ofFn | Batteries.Data.ByteArray | {n : ℕ} → (Fin n → UInt8) → ByteArray | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_17 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_3) [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_1} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} [inst_6 : Algebra ℝ 𝕜] [inst_7 : IsScalarTower ℝ 𝕜 F]
(x : 𝕜) (x_1 : TestFunction Ω F n), ∃ C, ∀ (x_2 y : E), dist ((x • x_1) x_2) ((x • x_1) y) ≤ C | false |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.IsCyclotomicExtension.eq_self_sdiff_zero._simp_1_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
IsCyclotomicExtension.Rat.Three.lambda_pow_four_dvd_cube_add_one_of_dvd_add_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) [inst_1 : NumberField K]
[IsCyclotomicExtension {3} ℚ K] {x : NumberField.RingOfIntegers K},
hζ.toInteger - 1 ∣ x + 1 → (hζ.toInteger - 1) ^ 4 ∣ x ^ 3 + 1 | true |
IsManifold.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
{M : Type u_4} →
[inst_4 : TopologicalSpace M] →
[inst_5 : ChartedSpace H M] →
{motive : IsManifold I n M → Sort u} →
(t : IsManifold I n M) →
([toHasGroupoid : HasGroupoid M (contDiffGroupoid n I)] → motive ⋯) → motive t | false |
MeasureTheory.VectorMeasure.of_biUnion_finset | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M]
{v : MeasureTheory.VectorMeasure α M} [T2Space M] {ι : Type u_4} {s : Finset ι} {f : ι → Set α},
(↑s).PairwiseDisjoint f → (∀ b ∈ s, MeasurableSet (f b)) → ↑v (⋃ b ∈ s, f b) = ∑ p ∈ s, ↑v (f p) | true |
Set.powersetCard.ofFinEmb.eq_1 | Mathlib.Data.Set.PowersetCard | ∀ (n : ℕ) (β : Type u_2) (f : Fin n ↪ β), Set.powersetCard.ofFinEmb n β f = Set.powersetCard.map n f ⟨Finset.univ, ⋯⟩ | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_extractLsb'_eq_extractLsb'._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {α : Sort u_1} {p : Prop} [inst : Decidable p] {x y : α}, ((if p then x else y) = x) = (¬p → y = x) | false |
UniformSpace.Completion.ring._proof_26 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
(a : UniformSpace.Completion α), a * 0 = 0 | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.indFVars | Lean.Elab.MutualInductive | Lean.Elab.Command.AddAndFinalizeContext✝ → Array Lean.Expr | true |
TopModuleCat.instAddCommGroupHom | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [inst : Ring R] → [inst_1 : TopologicalSpace R] → {X Y : TopModuleCat R} → AddCommGroup (X ⟶ Y) | true |
Filter.covariant_vadd | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β],
CovariantClass (Filter α) (Filter β) (fun x1 x2 => x1 +ᵥ x2) fun x1 x2 => x1 ≤ x2 | true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | true |
grade_strictMono | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α],
StrictMono (grade 𝕆) | true |
Vector.eraseIdx_set_lt | Init.Data.Vector.Erase | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {w : i < n} {j : ℕ} {a : α} (h : j < i),
(xs.set i a w).eraseIdx j ⋯ = (xs.eraseIdx j ⋯).set (i - 1) a ⋯ | true |
Action.FunctorCategoryEquivalence.functor_map_app | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {X Y : Action V G}
(f : X ⟶ Y) (x : CategoryTheory.SingleObj G), (Action.FunctorCategoryEquivalence.functor.map f).app x = f.hom | true |
Subfield.instPartialOrder | Mathlib.Algebra.Field.Subfield.Defs | {K : Type u} → [inst : DivisionRing K] → PartialOrder (Subfield K) | true |
FirstOrder.Language.age | Mathlib.ModelTheory.Fraisse | (L : FirstOrder.Language) → (M : Type w) → [L.Structure M] → Set (CategoryTheory.Bundled L.Structure) | true |
ContinuousMap.zero_comp | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [inst_3 : Zero γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 | true |
Std.Do.PredTrans.pure._proof_1 | Std.Do.PredTrans | ∀ {ps : Std.Do.PostShape} {α : Type u_1} (a : α), Std.Do.PredTrans.Conjunctive fun Q => Q.1 a | false |
Positive.instPowSubtypeLtOfNatNat_mathlib._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (x : { x // 0 < x }) (n : ℕ),
0 < ↑x ^ n | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.