name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
mul_le_mul_of_nonpos_of_nonneg' | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b c d : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], c ≤ a → b ≤ d → 0 ≤ a → d ≤ 0 → a * b ≤ c * d | true |
CategoryTheory.ShortComplex.Exact.isIso_imageToKernel | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C), S.Exact → CategoryTheory.IsIso (imageToKernel S.f S.g ⋯) | true |
Lean.KeyedDeclsAttribute.ExtensionState.declNames | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.ExtensionState γ → Lean.PHashSet Lean.Name | true |
LinearMap.mem_submoduleImage._simp_1 | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_10}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {O : Submodule R M} {ϕ : ↥O →ₗ[R] M'} {N : Submodule R M} {x : M'},
(x ∈ ϕ.submoduleImage N) = ∃ y, ∃ (yO : y ∈ O), y ∈ N ∧ ϕ ⟨y, yO⟩ = x | false |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.isFinite | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval → Bool | true |
Lean.Server.Test.Runner.Client.InteractiveGoals.mk | Lean.Server.Test.Runner | Array Lean.Server.Test.Runner.Client.InteractiveGoal → Lean.Server.Test.Runner.Client.InteractiveGoals | true |
SimpleGraph.Walk.support_toPath_subset | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v : V} (p : G.Walk u v), (↑p.toPath).support ⊆ p.support | true |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.pi_eq_zero._simp_1_2 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
IdealFilter.isTorsion_def | Mathlib.RingTheory.IdealFilter.Basic | ∀ {A : Type u_1} [inst : Ring A] (F : IdealFilter A) (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
F.IsTorsion M ↔ ∀ (m : M), F.IsTorsionElem m | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplex.0.CochainComplex.HomComplex.Cocycle.homOf._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.val_assemble₁_le._proof_1_1 | Init.Data.String.Decode | ∀ {w : UInt8}, w.toNat < 128 → ¬w.toNat ≤ 127 → False | false |
Concept.instPartialOrder | Mathlib.Order.Concept | {α : Type u_2} → {β : Type u_3} → {r : α → β → Prop} → PartialOrder (Concept α β r) | true |
_private.Init.Data.List.Lemmas.0.List.length_pos_iff_exists_mem.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : (∃ a, a ∈ l) → Prop) (x : ∃ a, a ∈ l),
(∀ (w : α) (h : w ∈ l), motive ⋯) → motive x | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.fixingSubgroup_map_conj_eq._simp_1_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | false |
Fin.dfoldrM.loop._unsafe_rec | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) | false |
MeasureTheory.aecover_closedBall | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : PseudoMetricSpace α] [OpensMeasurableSpace α] {x : α} {r : ι → ℝ},
Filter.Tendsto r l Filter.atTop → MeasureTheory.AECover μ l fun i => Metric.closedBall x (r i) | true |
CartanMatrix.isSimplyLaced_D | Mathlib.Data.Matrix.Cartan | ∀ (n : ℕ), (CartanMatrix.D n).IsSimplyLaced | true |
BitVec.twoPow | Init.Data.BitVec.Basic | (w : ℕ) → ℕ → BitVec w | true |
_private.Init.Data.Array.Monadic.0.Array.foldlM_filterMap.match_1.eq_1 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : (b : β) → motive (some b)) (h_2 : Unit → motive none),
(match some b with
| some b => h_1 b
| none => h_2 ()) =
h_1 b | true |
AddSubgroup.normalCore_le | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), H.normalCore ≤ H | true |
LocalSubring.noConfusion | Mathlib.RingTheory.LocalRing.LocalSubring | {P : Sort u} →
{R : Type u_1} →
{inst : CommRing R} →
{t : LocalSubring R} →
{R' : Type u_1} →
{inst' : CommRing R'} →
{t' : LocalSubring R'} → R = R' → inst ≍ inst' → t ≍ t' → LocalSubring.noConfusionType P t t' | false |
_private.Batteries.Data.String.Legacy.0.String.Legacy.posOfAux._proof_1 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos pos : String.Pos.Raw),
pos < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s pos).byteIdx < stopPos.byteIdx - pos.byteIdx | false |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.support_eq._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) | false |
List.pop_toArray | Init.Data.List.ToArray | ∀ {α : Type u_1} (l : List α), l.toArray.pop = l.dropLast.toArray | true |
_private.Lean.Util.Diff.0.Lean.Diff.diff.match_3 | Lean.Util.Diff | {α : Type} →
(motive : MProd ℕ (MProd ℕ (Array (Lean.Diff.Action × α))) → Sort u_1) →
(r : MProd ℕ (MProd ℕ (Array (Lean.Diff.Action × α)))) →
((i j : ℕ) → (out : Array (Lean.Diff.Action × α)) → motive ⟨i, j, out⟩) → motive r | false |
CategoryTheory.Abelian.extFunctorObj._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (n : ℕ), n + 0 = n | false |
_private.Mathlib.RingTheory.PolynomialAlgebra.0.PolyEquivTensor.left_inv._simp_1_3 | Mathlib.RingTheory.PolynomialAlgebra | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x | false |
Subgroup.toAddSubgroup._proof_2 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (x : AddSubgroup (Additive G)),
(fun S =>
let __src := Submonoid.toAddSubmonoid S.toSubmonoid;
{ toAddSubmonoid := __src, neg_mem' := ⋯ })
((fun S =>
let __src := AddSubmonoid.toSubmonoid S.toAddSubmonoid;
{ toSubmonoid := __src, inv_mem' := ... | false |
EuclideanGeometry.orthogonalProjection.congr_simp | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] (s : AffineSubspace 𝕜 P)
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection],
EuclideanGeometry.orthogonal... | true |
Tuple.comp_sort_eq_comp_iff_monotone | Mathlib.Data.Fin.Tuple.Sort | ∀ {n : ℕ} {α : Type u_1} [inst : LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)},
f ∘ ⇑σ = f ∘ ⇑(Tuple.sort f) ↔ Monotone (f ∘ ⇑σ) | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.cooper₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.casesOn | Std.Sync.Channel | {α : Type} →
{motive : Std.CloseableChannel.Bounded.State✝ α → Sort u} →
(t : Std.CloseableChannel.Bounded.State✝¹ α) →
((producers : Std.Queue (IO.Promise Bool)) →
(consumers : Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α)) →
(capacity : ℕ) →
(buf : Vector (IO.Ref... | false |
_private.Mathlib.Data.List.OffDiag.0.List.Nodup.offDiag._proof_1_1 | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} {l : List α},
l.Nodup → ∀ (x y : α), (List.count x l * List.count y l - if x = y then List.count x l else 0) ≤ 1 | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.infsep._simp_1_3 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {s : Set α} {a : α} (hs : s.Finite), (a ∈ hs.toFinset) = (a ∈ s) | false |
LinearMap.IsReflective.coroot._proof_1 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) {x : M} (hx : B.IsReflective x) (a b : M), Exists.choose ⋯ = Exists.choose ⋯ + Exists.choose ⋯ | false |
CompactlySupportedContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.CompactlySupported | Sort u →
{α : Type u_5} →
{β : Type u_6} →
[inst : TopologicalSpace α] →
[inst_1 : Zero β] →
[inst_2 : TopologicalSpace β] →
CompactlySupportedContinuousMap α β →
{α' : Type u_5} →
{β' : Type u_6} →
[inst' : TopologicalSpace α'] →... | false |
Std.Broadcast.Sync.send | Std.Sync.Broadcast | {α : Type} → Std.Broadcast.Sync α → α → IO ℕ | true |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_2 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | false |
WeierstrassCurve.Projective.add | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | true |
List.lex_nil | Init.Data.List.Basic | ∀ {α : Type u} {lt : α → α → Bool} [inst : BEq α] {as : List α}, as.lex [] lt = false | true |
Subring.unop_sup | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R] (S₁ S₂ : Subring Rᵐᵒᵖ), (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameState.mk.injEq | Lean.Elab.DeclNameGen | ∀ (seen : Lean.ExprSet) (consts : Lean.NameSet) (seen_1 : Lean.ExprSet) (consts_1 : Lean.NameSet),
({ seen := seen, consts := consts } = { seen := seen_1, consts := consts_1 }) = (seen = seen_1 ∧ consts = consts_1) | true |
CategoryTheory.Lax.LaxTrans.recOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{motive : CategoryTheory.Lax.LaxTrans F G → Sort u} →
(t : CategoryTheory.Lax.LaxTrans F G) →
((app : (a : B) → ... | false |
Lean.PersistentEnvExtension.noConfusionType | Lean.Environment | Sort u →
{α β σ : Type} → Lean.PersistentEnvExtension α β σ → {α' β' σ' : Type} → Lean.PersistentEnvExtension α' β' σ' → Sort u | false |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.termω | Mathlib.Analysis.InnerProductSpace.TwoDim | Lean.ParserDescr | true |
CategoryTheory.unop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᵒᵖ)
{Y Z : Cᵒᵖ} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).unop =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (Opposite.unop X) f.unop | true |
SetRel.IsWellFounded.eq_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (R : SetRel α α), R.IsWellFounded = WellFounded fun x1 x2 => (x1, x2) ∈ R | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.zero_φK | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
(CategoryTheory.ShortComplex.LeftHomologyMapData.zero h₁ h₂).φK = 0 | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.MatcherKey.mk._flat_ctor | Lean.Meta.Match.Match | Lean.Expr → Bool → Bool → Lean.Meta.Match.MatcherKey✝ | false |
ContinuousLinearMap.restrictScalars_smul | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {A : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} {R : Type u_4} {S : Type u_5} [inst : Semiring A] [inst_1 : Semiring R]
[inst_2 : Semiring S] [inst_3 : AddCommMonoid M₁] [inst_4 : Module A M₁] [inst_5 : Module R M₁]
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module A M₂] [inst_9 : Module ... | true |
Lean.Elab.TerminationHints.noConfusionType | Lean.Elab.PreDefinition.TerminationHint | Sort u → Lean.Elab.TerminationHints → Lean.Elab.TerminationHints → Sort u | false |
instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedAddCommGroupWithTop α] (n : ℕ) (a : Multiplicative αᵒᵈ),
DivInvMonoid.zpow (↑n.succ) a = DivInvMonoid.zpow (↑n) a * a | false |
MeasurableSMul.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α]
[toMeasurableConstSMul : MeasurableConstSMul M α],
autoParam (∀ (x : α), Measurable fun x_1 => x_1 • x) MeasurableSMul.measurable_smul_const._autoParam →
MeasurableSMul M α | true |
List.flatMap | Init.Prelude | {α : Type u} → {β : Type v} → (α → List β) → List α → List β | true |
PiNat.mem_cylinder_comm | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x y : (n : ℕ) → E n) (n : ℕ), y ∈ PiNat.cylinder x n ↔ x ∈ PiNat.cylinder y n | true |
CategoryTheory.Limits.instPreservesColimitsOfShapeDiscreteOfFiniteOfPreservesFiniteCoproducts | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (J : Type u) [Finite J] [CategoryTheory.Limits.PreservesFiniteCoproducts F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F | true |
ContinuousAlgEquiv.coeCLE_apply | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (a : A), ↑e a = e a | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real.0.RealRMK.integral_riesz_aux._simp_1_7 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | false |
NNRat.instContinuousSub | Mathlib.Topology.Instances.Rat | ContinuousSub ℚ≥0 | true |
Std.TreeMap.getKeyD_diff_of_not_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ \ t₂).getKeyD k fallback = t₁.getKeyD k fallback | true |
FinPartOrd.Iso.mk_inv | Mathlib.Order.Category.FinPartOrd | ∀ {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd), (FinPartOrd.Iso.mk e).inv = FinPartOrd.ofHom ↑e.symm | true |
Std.TreeSet.Raw.min?_insert_le_self | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k kmi : α},
(t.insert k).min?.get ⋯ = kmi → (cmp kmi k).isLE = true | true |
ContinuousMap.casesOn | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{motive : C(X, Y) → Sort u} →
(t : C(X, Y)) →
((toFun : X → Y) →
(continuous_toFun : Continuous toFun) →
motive { toFun := toFun, continuous_toFun :... | false |
_private.Mathlib.Topology.Instances.RatLemmas.0.«termℚ∞» | Mathlib.Topology.Instances.RatLemmas | Lean.ParserDescr | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal] (a : G), (↑a)⁻¹ = ↑a⁻¹ | false |
ArithmeticFunction.instAlgebra | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring S] → [Algebra R S] → Algebra R (ArithmeticFunction S) | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isCongruentCheck.go._unsafe_rec | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | false |
EReal.neg_eq_top_iff | Mathlib.Data.EReal.Operations | ∀ {x : EReal}, -x = ⊤ ↔ x = ⊥ | true |
ModuleCat.CoextendScalars.obj' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} → {S : Type u₂} → [inst : Ring R] → [inst_1 : Ring S] → (R →+* S) → ModuleCat R → ModuleCat S | true |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.pushNegBuiltin._sparseCasesOn_2 | Mathlib.Tactic.Push | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Order.Filter.Germ.Basic.0.Filter.Germ.IsConstant.match_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {β : Type u_1} {l : Filter α} (f : α → β) (motive : (∃ b, f =ᶠ[l] fun x => b) → Prop)
(x : ∃ b, f =ᶠ[l] fun x => b), (∀ (b : β) (hb : f =ᶠ[l] fun x => b), motive ⋯) → motive x | false |
Matroid.isBasis_iff_isBasis'_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis I X ↔ M.IsBasis' I X ∧ X ⊆ M.E | true |
ContinuousAffineMap.coe_const | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ (R : Type u_1) {V : Type u_2} {W : Type u_3} (P : Type u_4) {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (q : Q),
⇑(Cont... | true |
Polynomial.cyclotomic.roots_eq_primitiveRoots_val | Mathlib.RingTheory.Polynomial.Cyclotomic.Roots | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} [inst_1 : IsDomain R] [NeZero ↑n],
(Polynomial.cyclotomic n R).roots = (primitiveRoots n R).val | true |
Subtype.mk.hinj | Mathlib.Data.Subtype | ∀ {α : Sort u} {p : α → Prop} {val : α} {property : p val} {α_1 : Sort u} {p_1 : α_1 → Prop} {val_1 : α_1}
{property_1 : p_1 val_1}, α = α_1 → p ≍ p_1 → ⟨val, property⟩ ≍ ⟨val_1, property_1⟩ → α = α_1 ∧ p ≍ p_1 ∧ val ≍ val_1 | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.AnalyzeResult.maxS?._default | Mathlib.Tactic.FBinop | Option FBinopElab.SRec | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.mapGen_apply_apply_of_surjective.match_1_1 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : NonAssocSemiring M] [inst_1 : NonAssocSemiring N] {c : RingCon M} (f : M →+* N)
{x y : M} (motive : (∃ a b, c a b ∧ f a = f x ∧ f b = f y) → Prop) (x_1 : ∃ a b, c a b ∧ f a = f x ∧ f b = f y),
(∀ (a b : M) (h₁ : c a b) (h₂ : f a = f x) (h₃ : f b = f y), motive ⋯) → motive x_1 | false |
Module.FaithfullyFlat.iff_exact_iff_rTensor_exact | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
∀ {N1 : Type (max u v)} [inst_3 : AddCommGroup N1] [inst_4 : Module R N1] {N2 : Type (max u v)}
[inst_5 : AddCommGroup N2] [inst_6 : Module R N2] {N3 : Type (max u v)} [inst_7 : AddCo... | true |
Complex.addCommGroup._proof_11 | Mathlib.Data.Complex.Basic | ∀ (a b : ℂ), a + b = b + a | false |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_2 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R}, I.IsMaximal → NoZeroDivisors (R ⧸ I) | false |
UpperSemicontinuous.inf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} {β : Type u_5} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f g : α → β},
UpperSemicontinuous f → UpperSemicontinuous g → UpperSemicontinuous fun x => min (f x) (g x) | true |
Equiv.Perm.sigmaCongrRight_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : α → Type u_2}, (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a) | true |
UInt64.toUInt32_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt64.size), (UInt64.ofNatLT n hn).toUInt32 = UInt32.ofNat n | true |
_private.Lean.Compiler.IR.FreeVars.0.Lean.IR.MaxIndex.visitExpr | Lean.Compiler.IR.FreeVars | Lean.IR.Expr → Lean.IR.MaxIndex.M Unit | true |
ENNReal.toNNReal_zero | Mathlib.Data.ENNReal.Basic | ENNReal.toNNReal 0 = 0 | true |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_13 | Mathlib.LinearAlgebra.Goursat | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
Aesop.PhaseSpec.safe.elim | Aesop.Builder.Basic | {motive : Aesop.PhaseSpec → Sort u} →
(t : Aesop.PhaseSpec) → t.ctorIdx = 0 → ((info : Aesop.SafeRuleInfo) → motive (Aesop.PhaseSpec.safe info)) → motive t | false |
Std.DTreeMap.Internal.Impl.toList_map | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w}
{f : (a : α) → β a → γ a},
(Std.DTreeMap.Internal.Impl.map f t).toList = List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) t.toList | true |
ContinuousLinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | true |
Aesop.LocalRuleSet.mk.noConfusion | Aesop.RuleSet | {P : Sort u} →
{toBaseRuleSet : Aesop.BaseRuleSet} →
{simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems)} →
{simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size} →
{simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs)} →
{simprocsArrayNonempty : 0 < simprocsArray.size} →
... | false |
Nonneg.nat_ceil_coe | Mathlib.Algebra.Order.Nonneg.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedRing α] [inst_3 : FloorSemiring α]
(a : { r // 0 ≤ r }), ⌈↑a⌉₊ = ⌈a⌉₊ | true |
Std.DTreeMap.Internal.Impl.minKey?_insert!_le_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k} {km kmi : α},
t.minKey? = some km → (Std.DTreeMap.Internal.Impl.insert! k v t).minKey?.get ⋯ = kmi → (compare kmi km).isLE = true | true |
Set.inclusion_inclusion | Mathlib.Data.Set.Inclusion | ∀ {α : Type u_1} {s t u : Set α} (hst : s ⊆ t) (htu : t ⊆ u) (x : ↑s),
Set.inclusion htu (Set.inclusion hst x) = Set.inclusion ⋯ x | true |
CategoryTheory.ShortComplex.SnakeInput.L₀'_exact | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), S.L₀'.Exact | true |
Sym.coe_equivNatSumOfFintype_apply_apply | Mathlib.Data.Finsupp.Multiset | ∀ (α : Type u_1) [inst : DecidableEq α] (n : ℕ) [inst_1 : Fintype α] (s : Sym α n) (a : α),
↑((Sym.equivNatSumOfFintype α n) s) a = Multiset.count a ↑s | true |
Aesop.Script.STactic.ctorIdx | Aesop.Script.Tactic | Aesop.Script.STactic → ℕ | false |
SemiNormedGrp.explicitCokernel | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp} → (X ⟶ Y) → SemiNormedGrp | true |
Lean.Grind.Linarith.le_lt_combine_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | true |
AddSubsemigroup.toSubsemigroup_closure | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {A : Type u_5} [inst : Add A] (S : Set A),
AddSubsemigroup.toSubsemigroup (AddSubsemigroup.closure S) = Subsemigroup.closure (⇑Multiplicative.toAdd ⁻¹' S) | true |
Lean.Expr.containsFVar | Lean.Expr | Lean.Expr → Lean.FVarId → Bool | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.