name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MonadHom.ext_iff | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {T₁ T₂ : CategoryTheory.Monad C}
{x y : CategoryTheory.MonadHom T₁ T₂}, x = y ↔ x.app = y.app | true |
_private.Mathlib.GroupTheory.GroupAction.MultiplePrimitivity.0.MulAction.isMultiplyPreprimitive_congr._simp_1_3 | Mathlib.GroupTheory.GroupAction.MultiplePrimitivity | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {m : M},
(m ∈ fixingSubgroup M s) = ∀ y ∈ s, m • y = y | false |
WeierstrassCurve.Projective.neg_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P : Fin 3 → R},
W'.Equation P → P 2 = 0 → W'.neg P = -P 1 • ![0, 1, 0] | true |
Std.DTreeMap.Internal.Impl.minEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Intern... | false |
Pi.cancelCommMonoid | Mathlib.Algebra.Group.Pi.Basic | {I : Type u} → {f : I → Type v₁} → [(i : I) → CancelCommMonoid (f i)] → CancelCommMonoid ((i : I) → f i) | true |
QuotientGroup.quotientBot_symm_apply | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] (a : G), QuotientGroup.quotientBot.symm a = ↑a | true |
ISize.toInt16_or | Init.Data.SInt.Bitwise | ∀ (a b : ISize), (a ||| b).toInt16 = a.toInt16 ||| b.toInt16 | true |
Lean.Order.sup_le | Init.Internal.Order.Basic | ∀ {α : Sort u} [inst : Lean.Order.CompleteLattice α] {x : α} (c : α → Prop),
(∀ (y : α), c y → Lean.Order.PartialOrder.rel y x) → Lean.Order.PartialOrder.rel (Lean.Order.CompleteLattice.sup c) x | true |
MvQPF.Quot1.map | Mathlib.Data.QPF.Multivariate.Constructions.Quot | {n : ℕ} →
{F : TypeVec.{u} n → Type u} →
(R : ⦃α : TypeVec.{u} n⦄ → F α → F α → Prop) →
[inst : MvFunctor F] →
(∀ ⦃α β : TypeVec.{u} n⦄ (a b : F α) (f : α.Arrow β), R a b → R (MvFunctor.map f a) (MvFunctor.map f b)) →
⦃α β : TypeVec.{u} n⦄ → α.Arrow β → MvQPF.Quot1 R α → MvQPF.Quot1 R β | true |
Finset.sum_eq_sum_iff_single | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} {s : Finset ι} [inst : AddCommMonoid M] [IsRightCancelAdd M] {f g : ι → M} {i : ι},
i ∈ s → (∀ j ∈ s, j ≠ i → f j = g j) → (∑ j ∈ s, f j = ∑ j ∈ s, g j ↔ f i = g i) | true |
Real.one_le_cosh._simp_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (x : ℝ), (1 ≤ Real.cosh x) = True | false |
CategoryTheory.Precoverage.instPartialOrder._proof_1 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a b : CategoryTheory.Precoverage C),
(fun A B => A.coverings ≤ B.coverings) a b ∧ ¬(fun A B => A.coverings ≤ B.coverings) b a ↔
a.coverings ≤ b.coverings ∧ ¬b.coverings ≤ a.coverings | false |
fourier_gaussian_innerProductSpace | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {b : ℂ} {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
[inst_3 : MeasurableSpace V] [inst_4 : BorelSpace V],
0 < b.re →
∀ (w : V),
FourierTransform.fourier (fun v => Complex.exp (-b * ↑‖v‖ ^ 2)) w =
(↑Real.pi / b) ^ (↑(Module.finran... | true |
HomologicalComplex.homotopyCofiber.inrCompHomotopy._proof_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_3}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel],
(∀ (j : ι), ∃ i, c.Rel i j) →
∀ (j : ι),
... | false |
Con.group.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Group M] (c : Con M),
c.group =
{ toMonoid := c.monoid, toInv := c.hasInv, toDiv := c.hasDiv, div_eq_mul_inv := ⋯, zpow := fun a a_1 => a_1 ^ a,
zpow_zero' := ⋯, zpow_succ' := ⋯, zpow_neg' := ⋯, inv_mul_cancel := ⋯ } | true |
AlgebraicGeometry.QuasiCompactCover.instOfIsEmptyCarrierCarrierCommRingCat | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {S : AlgebraicGeometry.Scheme} {𝒰 : CategoryTheory.PreZeroHypercover S} [IsEmpty ↥S],
AlgebraicGeometry.QuasiCompactCover 𝒰 | true |
SaturatedSubmonoid.mem_toSubmonoid._simp_2 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : MulOneClass M] {s : SaturatedSubmonoid M} {x : M}, (x ∈ s.toSubmonoid) = (x ∈ s) | false |
Sublattice.instDistribLatticeCoe._proof_2 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : DistribLattice α] (L : Sublattice α) {x y : ↥L}, ↑x ≤ ↑y ↔ ↑x ≤ ↑y | false |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.IsMatching.coeSubgraph._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), (↑a ∈ S) = True | false |
_private.Mathlib.Order.RelSeries.0.LTSeries.apply_add_index_le_apply_add_index_nat._proof_1_6 | Mathlib.Order.RelSeries | ∀ (p : LTSeries ℕ) (j : ℕ), j + 1 < p.length + 1 → j < p.length + 1 | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.dist_le_distortion_mul._simp_1_2 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), ↑(nndist x y) = dist x y | false |
_private.Mathlib.Algebra.Quaternion.0.instNontrivialQuaternion._proof_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Zero R] [inst_1 : One R] [inst_2 : Neg R] [Nontrivial R], Nontrivial (Quaternion R) | false |
ContinuousAffineMap.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Affine.ContinuousAffineMap | ∀ {𝕜 : Type u_1} {W : Type u_2} [inst : NormedAddCommGroup W] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 W], SMulCommClass 𝕜 𝕜 W | false |
Nat.count_monotone | Mathlib.Data.Nat.Count | ∀ (p : ℕ → Prop) [inst : DecidablePred p], Monotone (Nat.count p) | true |
invertibleDiv | Mathlib.Algebra.GroupWithZero.Invertible | {α : Type u} → [inst : GroupWithZero α] → (a b : α) → [Invertible a] → [Invertible b] → Invertible (a / b) | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.normal | Std.Sync.Channel | {α : Type} → IO.Promise (Option α) → Std.CloseableChannel.Consumer✝ α | true |
FractionalIdeal.wrapped._@.Mathlib.RingTheory.FractionalIdeal.Basic.1107666208._hygCtx._hyg.2 | Mathlib.RingTheory.FractionalIdeal.Basic | Subtype (Eq @FractionalIdeal.definition✝) | false |
sq_tsub_sq | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [AddLeftReflectLE R] (a b : R), a ^ 2 - b ^ 2 = (a + b) * (a - b) | true |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.false | Lean.Meta.InferType | Lean.Meta.ArrowPropResult✝ | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder.0.CStarAlgebra.convexOn_ringInverse._proof_1_8 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.RingInverseOrder | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [inst_2 : StarOrderedRing A] ⦃x y : A⦄ ⦃a b : ℝ⦄,
0 ≤ b →
IsStrictlyPositive ((CFC.conjSqrt (Ring.inverse x)) y) →
0 < a → IsStrictlyPositive (a • 1 + b • (CFC.conjSqrt (Ring.inverse x)) y) | false |
Filter.pi_inj | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f₁ f₂ : (i : ι) → Filter (α i)} [∀ (i : ι), (f₁ i).NeBot],
Filter.pi f₁ = Filter.pi f₂ ↔ f₁ = f₂ | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.NF.zero_of_zero._simp_1_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ {o : ONote}, o.NFBelow 0 = (o = 0) | false |
Lean.Doc.initFn._@.Lean.Elab.DocString.1180459801._hygCtx._hyg.2 | Lean.Elab.DocString | IO (Lean.SimpleScopedEnvExtension (Lean.Name × Lean.Name) (Lean.NameMap (Array Lean.Name))) | false |
Nat.prod_pow_factorization_eq_self | Mathlib.Data.Nat.Factorization.Defs | ∀ {f : ℕ →₀ ℕ}, (∀ p ∈ f.support, Nat.Prime p) → (f.prod fun x1 x2 => x1 ^ x2).factorization = f | true |
Std.DTreeMap.Internal.Impl.Const.alter._proof_22 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (sz : ℕ) (k' : α) (v' : β) (l' r' : Std.DTreeMap.Internal.Impl α fun x => β),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced → r'.Balanced | false |
_private.Std.Time.Format.Basic.0.Std.Time.Reason.yes.elim | Std.Time.Format.Basic | {motive : Std.Time.Reason✝ → Sort u} →
(t : Std.Time.Reason✝¹) → Std.Time.Reason.ctorIdx✝ t = 0 → motive Std.Time.Reason.yes✝ → motive t | false |
Lean.Elab.Term.MVarErrorKind.hole.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.MVarErrorKind → Sort u} →
(t : Lean.Elab.Term.MVarErrorKind) → t.ctorIdx = 1 → motive Lean.Elab.Term.MVarErrorKind.hole → motive t | false |
commGroupOfIsUnit._proof_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [hM : CommMonoid M] (h : ∀ (a : M), IsUnit a) (a b : M), a / b = a * b⁻¹ | false |
Lean.Elab.Command.AssertExists.mk.injEq | Lean.Elab.AssertExists | ∀ (isDecl : Bool) (givenName modName : Lean.Name) (isDecl_1 : Bool) (givenName_1 modName_1 : Lean.Name),
({ isDecl := isDecl, givenName := givenName, modName := modName } =
{ isDecl := isDecl_1, givenName := givenName_1, modName := modName_1 }) =
(isDecl = isDecl_1 ∧ givenName = givenName_1 ∧ modName = modN... | true |
Lean.Meta.Grind.EMatch.State.delayedThmInsts | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → Lean.PHashMap Lean.Meta.Sym.ExprPtr (List Lean.Meta.Grind.DelayedTheoremInstance) | true |
Lean.Firefox.FrameTable.innerWindowID | Lean.Util.Profiler | Lean.Firefox.FrameTable → Array (Option Lean.Json) | true |
Lean.Elab.Term.Do.mkIte | Lean.Elab.Do.Legacy | Lean.Syntax →
Lean.Syntax →
Lean.Syntax →
Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.CodeBlock → Lean.Elab.TermElabM Lean.Elab.Term.Do.CodeBlock | true |
_private.Mathlib.Data.TypeVec.0.TypeVec.prod.fst.match_1.eq_1 | Mathlib.Data.TypeVec | ∀ (motive : (x : ℕ) → TypeVec.{u_1} x → TypeVec.{u_1} x → Fin2 x → Sort u_2) (n : ℕ) (α β : TypeVec.{u_1} n.succ)
(i : Fin2 n) (h_1 : (n : ℕ) → (α β : TypeVec.{u_1} n.succ) → (i : Fin2 n) → motive n.succ α β i.fs)
(h_2 : (n : ℕ) → (x x_1 : TypeVec.{u_1} n.succ) → motive n.succ x x_1 Fin2.fz),
(match n.succ, α, β,... | true |
Lean.Level.any | Lean.Level | Lean.Level → (Lean.Level → Bool) → Bool | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instBEqLambdaTheoremArgs.beq.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.LambdaTheoremArgs → Mathlib.Meta.FunProp.LambdaTheoremArgs → Sort u_1) →
(x x_1 : Mathlib.Meta.FunProp.LambdaTheoremArgs) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremArgs.id Mathlib.Meta.FunProp.LambdaTheoremArgs.id) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremAr... | false |
MeasurableInf | Mathlib.MeasureTheory.Order.Lattice | (M : Type u_1) → [MeasurableSpace M] → [Min M] → Prop | true |
Lean.Elab.Frontend.getInputContext | Lean.Elab.Frontend | Lean.Elab.Frontend.FrontendM Lean.Parser.InputContext | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj.0.DependsOn.lmarginalPartialTraj_of_le._proof_1_5 | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {a b : ℕ} (c : ℕ) (x : (n : ℕ) → X n) (y : (i : ↥(Finset.Ioc b c)) → X ↑i) (i : ℕ),
a ≤ b → i ≤ a → ∀ (h : b < i ∧ i ≤ c), y ⟨i, ⋯⟩ = x i | false |
smul_mul_smul | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_5} {β : Type u_6} [inst : Mul α] [inst_1 : Mul β] [inst_2 : SMul α β] [IsScalarTower α β β]
[IsScalarTower α α β] [SMulCommClass α β β] (a : α) (b : β) (c : α) (d : β), a • b * c • d = (a * c) • (b * d) | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.nameNotRoundtrippable | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Name → Bool | true |
CategoryTheory.Limits.colimit.hom_ext_iff | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] {X : C}
{f f' : CategoryTheory.Limits.colimit F ⟶ X},
f = f' ↔
∀ (j : J),
CategoryTheory.CategoryStruct.comp... | true |
_private.Mathlib.Analysis.Normed.Module.Basic.0.NormedSpace.unbounded_univ.match_1_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] (R : ℝ) (motive : (∃ x, R < ‖x‖) → Prop) (x : ∃ x, R < ‖x‖),
(∀ (x : E) (hx : R < ‖x‖), motive ⋯) → motive x | false |
ConvexOn.sup | 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 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
[PosSMulStrictMono 𝕜 β] {s : Set E} {f g : E → β}, ConvexOn 𝕜 s f → Conv... | true |
Lean.Compiler.LCNF.Check.Pure.State.recOn | Lean.Compiler.LCNF.Check | {motive : Lean.Compiler.LCNF.Check.Pure.State → Sort u} →
(t : Lean.Compiler.LCNF.Check.Pure.State) → ((all : Lean.FVarIdHashSet) → motive { all := all }) → motive t | false |
_private.Mathlib.CategoryTheory.Monoidal.Preadditive.0.CategoryTheory.rightDistributor_inv._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
Part.lawfulFix | Mathlib.Control.LawfulFix | {α : Type u_1} → LawfulFix (Part α) | true |
leftLim_eq_of_tendsto | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace β] [hα : TopologicalSpace α]
[h'α : OrderTopology α] [T2Space β] {f : α → β} {a : α} {y : β},
nhdsWithin a (Set.Iio a) ≠ ⊥ → Filter.Tendsto f (nhdsWithin a (Set.Iio a)) (nhds y) → Function.leftLim f a = y | true |
OrderMonoidHom.inr_apply | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β]
(y : β), (OrderMonoidHom.inr α β) y = (1, y) | true |
UpperHalfPlane.coe_injective | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | Function.Injective UpperHalfPlane.coe | true |
CategoryTheory.HomOrthogonal.matrixDecomposition._proof_5 | Mathlib.CategoryTheory.Preadditive.HomOrthogonal | ∀ {C : Type u_1} {ι : Type u_2} {s : ι → C} {α β : Type} {f : α → ι} {g : β → ι} (j : α) (k : β),
f j = g k → s (f j) = s (g k) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Var.0.Lean.Meta.Grind.Arith.Cutsat.registerNonlinearOcc | Lean.Meta.Tactic.Grind.Arith.Cutsat.Var | Lean.Expr → Int.Linear.Var → Lean.Meta.Grind.GoalM Unit | true |
AddSubmonoid.addUnits._proof_2 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) {x : AddUnits M},
x ∈ (AddSubmonoid.comap (AddUnits.coeHom M) S ⊓ -AddSubmonoid.comap (AddUnits.coeHom M) S).carrier →
-x ∈ ↑(AddSubmonoid.comap (AddUnits.coeHom M) S) ∧ -x ∈ ↑(-AddSubmonoid.comap (AddUnits.coeHom M) S) | false |
Lean.LocalContext.ctorIdx | Lean.LocalContext | Lean.LocalContext → ℕ | false |
Vector.foldl_flatten | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {m n : ℕ} {f : β → α → β} {b : β} {xss : Vector (Vector α m) n},
Vector.foldl f b xss.flatten = Vector.foldl (fun b xs => Vector.foldl f b xs) b xss | true |
Int.bitwise | Mathlib.Data.Int.Bitwise | (Bool → Bool → Bool) → ℤ → ℤ → ℤ | true |
Lean.Grind.Bool.ne_of_eq_false_of_eq_true | Init.Grind.Lemmas | ∀ {a b : Bool}, a = false → b = true → (a = b) = False | true |
BddLat.mk._flat_ctor | Mathlib.Order.Category.BddLat | (carrier : Type u_1) → [str : Lattice carrier] → [isBoundedOrder : BoundedOrder carrier] → BddLat | false |
_private.Mathlib.LinearAlgebra.Finsupp.Supported.0.Finsupp.supported_iInter._simp_1_1 | Mathlib.LinearAlgebra.Finsupp.Supported | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set α} (p : α →₀ M), (p ∈ Finsupp.supported M R s) = (↑p.support ⊆ s) | false |
Composition.ne_single_iff | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (hn : 0 < n) {c : Composition n}, c ≠ Composition.single n hn ↔ ∀ (i : Fin c.length), c.blocksFun i < n | true |
Lean.Json.num.noConfusion | Lean.Data.Json.Basic | {P : Sort u} → {n n' : Lean.JsonNumber} → Lean.Json.num n = Lean.Json.num n' → (n = n' → P) → P | false |
_private.Init.Data.UInt.Lemmas.0.UInt32.zero_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, (b ≤ a) = ¬a < b | false |
Set.subset_smul_set_iff | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A B : Set β} {a : α}, A ⊆ a • B ↔ a⁻¹ • A ⊆ B | true |
Polynomial.normalizedFactors_cyclotomic_card | Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p f n : ℕ},
Fintype.card K = p ^ f →
∀ (hn : p.Coprime n) [hp : Fact (Nat.Prime p)] [inst_2 : DecidableEq K],
(UniqueFactorizationMonoid.normalizedFactors (Polynomial.cyclotomic n K)).toFinset.card =
n.totient / orderOf (ZMod.unitOfCoprime (p ^... | true |
Lean.Parser.ParserCategory.recOn | Lean.Parser.Basic | {motive : Lean.Parser.ParserCategory → Sort u} →
(t : Lean.Parser.ParserCategory) →
((declName : Lean.Name) →
(kinds : Lean.Parser.SyntaxNodeKindSet) →
(tables : Lean.Parser.PrattParsingTables) →
(behavior : Lean.Parser.LeadingIdentBehavior) →
motive { declName := declN... | false |
Lean.IR.MaxIndex.State._sizeOf_1 | Lean.Compiler.IR.FreeVars | Lean.IR.MaxIndex.State → ℕ | false |
ExpGrowth.expGrowthInf_inv | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u : ℕ → ENNReal}, ExpGrowth.expGrowthInf u⁻¹ = -ExpGrowth.expGrowthSup u | true |
Lean.Compiler.LCNF.CollectLevelParams.visitLetValue | Lean.Compiler.LCNF.Level | Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Lean.CollectLevelParams.Visitor | true |
_private.Mathlib.Tactic.NormNum.Pow.0.Mathlib.Meta.NormNum.evalZPow._proof_1 | Mathlib.Tactic.NormNum.Pow | ∀ {u : Lean.Level} {α : Q(Type u)} (e a : Q(«$α»)) (b : Q(ℤ)) (_c : Q(DivisionSemiring «$α»)), «$e» =Q «$a» ^ «$b» | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.unusedVariables.match_6 | Lean.Linter.UnusedVariables | (motive : Option Lean.Syntax.Stack → Sort u_1) →
(x : Option Lean.Syntax.Stack) →
((id' : Lean.Syntax) → (snd : ℕ) → (stack : List (Lean.Syntax × ℕ)) → motive (some ((id', snd) :: stack))) →
((x : Option Lean.Syntax.Stack) → motive x) → motive x | false |
AlgCat.instAlgebraElemForallObjCompForgetAlgHomCarrierSections._aux_3 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_1} →
[inst : CommRing R] →
{J : Type u_2} →
[inst_1 : CategoryTheory.Category.{u_4, u_2} J] →
(F : CategoryTheory.Functor J (AlgCat R)) → R →+* ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections | false |
Lean.Elab.Term.FunBinders.State.expectedType? | Lean.Elab.Binders | Lean.Elab.Term.FunBinders.State → Option Lean.Expr | true |
AddSubgroup.mem_closure | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {k : Set G} {x : G},
x ∈ AddSubgroup.closure k ↔ ∀ (K : AddSubgroup G), k ⊆ ↑K → x ∈ K | true |
Mathlib.Tactic.LinearCombination.Expanded.ctorElimType | Mathlib.Tactic.LinearCombination | {motive : Mathlib.Tactic.LinearCombination.Expanded → Sort u} → ℕ → Sort (max 1 u) | false |
HasStrictDerivAt.div | Mathlib.Analysis.Calculus.Deriv.Inv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_1} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c d : 𝕜 → 𝕜'} {c' d' : 𝕜'},
HasStrictDerivAt c c' x →
HasStrictDerivAt d d' x → d x ≠ 0 → HasStrictDerivAt (c / d) ((c' * d x - c x * d') / d x ^ 2) x | true |
Std.IterM.forIn_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} {o : Type u_1 → Type u_4} {α β β₂ γ : Type u_1} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o] [LawfulMonad o] [inst_6 : MonadAttach n]
[WeaklyLawfulMonadAttach n] [inst_8 : MonadLiftT m n] [LawfulMonadLiftT m n] [inst_10 ... | true |
SimpleGraph.IsHamiltonian.mono | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} [inst_1 : Fintype α] {H : SimpleGraph α},
G ≤ H → G.IsHamiltonian → H.IsHamiltonian | true |
AlgebraicGeometry.surjective_isZariskiLocalAtTarget | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | AlgebraicGeometry.IsZariskiLocalAtTarget @AlgebraicGeometry.Surjective | true |
PiTensorProduct.instSemiring._proof_9 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (A i)]
[inst_2 : (i : ι) → Algebra R (A i)] (a b c : PiTensorProduct R fun i => A i), a * b * c = a * (b * c) | false |
IsAddFoelner.comp_tendsto | Mathlib.MeasureTheory.Group.FoelnerFilter | ∀ {G : Type u_1} {X : Type u_2} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} [inst_1 : AddGroup G]
[inst_2 : AddAction G X] {ι : Type u_3} {l : Filter ι} {F : ι → Set X} {ι' : Type u_4} {l' : Filter ι'} {φ : ι' → ι},
IsAddFoelner G μ l F → Filter.Tendsto φ l' l → IsAddFoelner G μ l' (F ∘ φ) | true |
SmoothBumpCovering.embeddingPiTangent_coe | Mathlib.Geometry.Manifold.WhitneyEmbedding | ∀ {ι : Type uι} {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{H : Type uH} [inst_3 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type uM} [inst_4 : TopologicalSpace M]
[inst_5 : ChartedSpace H M] [inst_6 : IsManifold I (↑⊤) M] [inst_7 : T2Space M]... | true |
CategoryTheory.MonoidalCategory.DayConvolution.associator_hom_unit_unit_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(F G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G]
(H : Ca... | true |
ArithmeticFunction.instSemiring._proof_5 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Semiring R] (f : ArithmeticFunction R), f * 0 = 0 | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.of_prefixFunction_eq | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice} {stackPos needlePos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos →
needlePos ≠ 0 →
∀ {k : ℕ} {hki : needlePos.byteIdx - 1 < pat.copy.toByteArray.size},
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ ... | true |
Urysohns.CU.mk.injEq | Mathlib.Topology.UrysohnsLemma | ∀ {X : Type u_2} [inst : TopologicalSpace X] {P : Set X → Set X → Prop} (C U : Set X) (P_C_U : P C U)
(closed_C : IsClosed C) (open_U : IsOpen U) (subset : C ⊆ U)
(hP :
∀ {c u : Set X},
IsClosed c → P c u → IsOpen u → c ⊆ u → ∃ v, IsOpen v ∧ c ⊆ v ∧ closure v ⊆ u ∧ P c v ∧ P (closure v) u)
(C_1 U_1 : Se... | true |
Std.DHashMap.Internal.Raw₀.filter_key_equiv_self_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α] {f : α → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter (fun k x => f k) m)).Equiv ↑m ↔
∀ (a : α) (h : m.contains a = true), f (m.getKey a h) = true) | true |
Action.FunctorCategoryEquivalence.counitIso._proof_4 | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] {G : Type u_1} [inst_1 : Monoid G]
{X Y : CategoryTheory.Functor (CategoryTheory.SingleObj G) V} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((Action.FunctorCategoryEquivalence.inverse.comp Action.FunctorCategoryEquivalence.functor).map f)
... | false |
ExceptCpsT.run_pure | Init.Control.ExceptCps | ∀ {m : Type u_1 → Type u_2} {ε α : Type u_1} {x : α} [inst : Monad m], (pure x).run = pure (Except.ok x) | true |
Matrix.transpose_nonsing_inv | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α),
A⁻¹.transpose = A.transpose⁻¹ | true |
CategoryTheory.Subfunctor.equivalenceMonoOver | Mathlib.CategoryTheory.Subfunctor.Subobject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor C (Type w)) → CategoryTheory.Subfunctor F ≌ CategoryTheory.MonoOver F | true |
MeasureTheory.Lp.simpleFunc._proof_5 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {α : Type u_1} (E : Type u_2) [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] (p : ENNReal)
(μ : MeasureTheory.Measure α), ∃ s, MeasureTheory.AEEqFun.mk ⇑s ⋯ = ↑0 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.