name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicGeometry.Scheme.geometricFiber._proof_4 | Mathlib.AlgebraicGeometry.Sites.Etale | ∀ (Ω : Type u_1) [inst : Field Ω] [IsSepClosed Ω] {S : AlgebraicGeometry.Scheme},
∀ R ∈ AlgebraicGeometry.Scheme.etaleTopology S,
∀ (f : AlgebraicGeometry.Spec ↧Ω ⟶ S),
∃ Y f_1,
∃ (_ : R.arrows f_1),
∃ y,
(CategoryTheory.ConcreteCategory.hom
((CategoryTheory.c... | null | false |
ack_inj_left | Mathlib.Computability.Ackermann | ∀ {m₁ m₂ n : ℕ}, ack m₁ n = ack m₂ n ↔ m₁ = m₂ | null | true |
solvable_of_ker_le_range | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} [inst : Group G] {G' : Type u_3} {G'' : Type u_4} [inst_1 : Group G'] [inst_2 : Group G'']
(f : G' →* G) (g : G →* G''),
g.ker ≤ f.range → ∀ [hG' : Group.IsSolvable G'] [hG'' : Group.IsSolvable G''], Group.IsSolvable G | **Alias** of `Group.isSolvable_of_ker_le_range`. | true |
StarMemClass.instStar._proof_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Star R] [inst_1 : SetLike S R] [hS : StarMemClass S R] (s : S) (r : ↥s),
star ↑r ∈ s | null | false |
_private.Mathlib.Algebra.Algebra.Subalgebra.Pointwise.0.Subalgebra.mul_toSubmodule_le._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Pointwise | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : A}, (x ∈ Subalgebra.toSubmodule S) = (x ∈ S) | null | false |
IsOrderedRing.toCharZero | Mathlib.Algebra.Order.Ring.Defs | ∀ {R : Type u} [inst : Ring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Nontrivial R], CharZero R | A nontrivial ordered ring is of characteristic zero.
This is not made a global instance for performance reasons. | true |
Set.forall_neg_mem._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s : Set α} {p : α → Prop}, (∀ (x : α), -x ∈ s → p x) = ∀ x ∈ s, p (-x) | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_151 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬hash (llhs.arithShiftRight lrhs) ≠ hash (rlhs.arithShiftRight rrhs) →
∀ (h1 : lw = rw), ¬h1 ▸ lrhs = rrhs → ¬llhs.arithShiftRigh... | null | false |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.instLawfulEqOrdPlainDateTime._simp_1 | Std.Time.DateTime.PlainDateTime | ∀ {α : Sort u_1} {cmp₁ cmp₂ : α → α → Ordering} {a b : α},
(compareLex cmp₁ cmp₂ a b = Ordering.eq) = (cmp₁ a b = Ordering.eq ∧ cmp₂ a b = Ordering.eq) | null | false |
Valuation.exists_div_eq_of_surjective | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {K : Type u_7} [inst : DivisionRing K] {Γ₀ : Type u_8} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
{v : Valuation K Γ₀}, Function.Surjective ⇑v → ∀ (γ : Γ₀ˣ), ∃ r s, 0 < v r ∧ 0 < v s ∧ v r / v s = ↑γ | null | true |
Int32.and_neg_one | Init.Data.SInt.Bitwise | ∀ {a : Int32}, a &&& -1 = a | null | true |
Field.embEquivOfAdjoinSplits._proof_4 | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u_3) (E : Type u_1) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type u_2)
[inst_3 : Field K] [inst_4 : Algebra F K] {S : Set E},
IntermediateField.adjoin F S = ⊤ →
(∀ s ∈ S, IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
Algebra.IsAlgebraic F E →... | null | false |
Lean.Meta.Simp.ConfigWithOptions | Lean.Elab.Tactic.Simp | Type | Configuration for `simp`, for supporting tactic configuration option syntax.
| true |
ONote.split_dvd | Mathlib.SetTheory.Ordinal.Notation | ∀ {o o' : ONote} {m : ℕ} [o.NF], o.split = (o', m) → Ordinal.omega0 ∣ o'.repr | null | true |
instIsMulFGMultiplicativeOfIsAddFG | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_3} [inst : Add M] [IsAddFG M], IsMulFG (Multiplicative M) | null | true |
CommRingCat.piFanIsLimit._proof_1 | Mathlib.Algebra.Category.Ring.Constructions | ∀ {ι : Type u_1} (R : ι → CommRingCat) (s : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor R))
(i : CategoryTheory.Discrete ι),
CategoryTheory.CategoryStruct.comp (CommRingCat.ofHom (RingHom.pi fun i => CommRingCat.Hom.hom (s.π.app { as := i })))
((CommRingCat.piFan R).π.app i) =
s.π.app i | null | false |
Std.Rxo.Iterator.step_eq_step | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α] {it : Std.Iter α},
it.step = ⟨Std.Rxo.Iterator.step it, ⋯⟩ | null | true |
isProperMap_dist | Mathlib.Topology.MetricSpace.ProperSpace.Lemmas | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [ProperSpace α] (x : α), IsProperMap (dist x) | null | true |
ZFClass._aux_Mathlib_SetTheory_ZFC_Class___unexpand_ZFClass_sInter_1 | Mathlib.SetTheory.ZFC.Class | Lean.PrettyPrinter.Unexpander | null | false |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Vector.0.Std.Iterators.Types.ArrayIterator.instIterator.match_1.eq_2 | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it : Std.IterM m α)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.Iter... | null | true |
Rand.split.match_1 | Mathlib.Control.Random | {g : Type} → (motive : g × g → Sort u_1) → (x : g × g) → ((r1 r2 : g) → motive (r1, r2)) → motive x | null | false |
csInf_singleton | Mathlib.Order.ConditionallyCompletePartialOrder.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderInf α] (a : α), sInf {a} = a | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic.0.NumberField.mixedEmbedding.det_matrixToStdBasis._simp_1_8 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
ωCPO.ctorIdx | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ | null | false |
symmDiff_symmDiff_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a b c : α),
symmDiff (symmDiff a b) c = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) ⊔ c \ (a ⊔ b) ⊔ a ⊓ b ⊓ c | null | true |
eq_zero_of_nonpos | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], a ≤ 0 → a = 0 | **Alias** of the forward direction of `nonpos_iff_eq_zero`. | true |
CategoryTheory.Abelian.SpectralObject.δToCycles._proof_3 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ : ℤ)
(hn₁ : n₀ + 1 = n₁), CategoryTheory.Cat... | null | false |
Metric.IsCover.anti | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {ε : NNReal} {s t N : Set X},
s ⊆ t → Metric.IsCover ε t N → Metric.IsCover ε s N | null | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.at_least_as_long_as_coind._simp_1_9 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b : α}, (a - b = 0) = (a ≤ b) | null | false |
List.nextOr_infix_of_mem_dropLast | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α}, a ∈ l.dropLast → ∀ (d : α), [a, l.nextOr a d] <:+: l | null | true |
Matrix.toLin_symm | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_3} {n : Type u_4} [inst_1 : Fintype n] [inst_2 : Finite m]
[inst_3 : DecidableEq n] {M₁ : Type u_5} {M₂ : Type u_6} [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₁] [inst_7 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis... | null | true |
Int.cast_lt._gcongr_2 | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : AddCommGroupWithOne R] [inst_1 : PartialOrder R] [AddLeftMono R] [ZeroLEOneClass R] [NeZero 1]
{m n : ℤ}, m < n → ↑m < ↑n | null | false |
UpperHalfPlane.denom_cocycle | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g h : GL (Fin 2) ℝ) {z : ℂ},
z.im ≠ 0 →
UpperHalfPlane.denom (g * h) z =
UpperHalfPlane.denom g (UpperHalfPlane.num h z / UpperHalfPlane.denom h z) * UpperHalfPlane.denom h z | null | true |
Equiv.Perm.mem_toCycle_iff_support._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {x : α} (f : Equiv.Perm α) (hf : f.IsCycle),
(x ∈ f.toCycle hf) = (f x ≠ x) | null | false |
AddGroupTopology.toTopologicalSpace_le | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u} [inst : AddGroup α] {x y : AddGroupTopology α}, x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y | null | true |
LinearIsometry.inr._proof_1 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ (E : Type u_2) (F : Type u_1) [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F],
Isometry ⇑(AddMonoidHom.inr E F) | null | false |
CategoryTheory.ShortComplex.hasLeftHomology_iff_op | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), S.HasLeftHomology ↔ S.op.HasRightHomology | null | true |
Lean.JsonRpc.ErrorCode.workerCrashed | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode | null | true |
LinearEquiv.ofLinear_toLinearMap | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : ... | **Alias** of `LinearEquiv.toLinearMap_ofLinearMap`. | true |
Nat.mul_add_div._f | Init.Data.Nat.Lemmas | ∀ {m : ℕ},
m > 0 →
∀ (x : ℕ) (f : Nat.below (motive := fun x => ∀ (y : ℕ), (m * x + y) / m = x + y / m) x) (y : ℕ),
(m * x + y) / m = x + y / m | null | false |
mul_left_inj._simp_2 | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_1} [inst : Mul G] [IsRightCancelMul G] (a : G) {b c : G}, (b * a = c * a) = (b = c) | null | false |
Lean.ScopedEnvExtension.Descr.toOLeanEntry | Lean.ScopedEnvExtension | {α β σ : Type} → Lean.ScopedEnvExtension.Descr α β σ → β → α | null | true |
Lean.Meta.Simp.Arith.Nat.LinearCnstr.toArith | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Array Lean.Expr → Lean.Meta.Simp.Arith.Nat.LinearCnstr → Lean.MetaM Lean.Expr | null | true |
List.length_eq_succ_iff | Mathlib.Data.List.Basic | ∀ {α : Type u} {n : ℕ} {l : List α}, l.length = n + 1 ↔ ∃ h t, h :: t = l ∧ t.length = n | null | true |
Lean.Meta.introSubstEq | Lean.Meta.Tactic.Subst | Lean.MVarId → optParam Bool false → Lean.MetaM (Lean.Meta.FVarSubst × Lean.MVarId) | Given a goal `(a = b) → goal[b]`, creates a new goal `goal[a]`, clearing `b`.
This is essentially `intro h; subst h`, but in the case that `b` is a free variable and has no
forward dependencies implements this without introducing the equality, which can make a difference
in terms of performance.
If `substLHS = true`,... | true |
Std.Do.Internal.MayReturn.canReturn | Std.Do.Internal.Ensures.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : MonadAttach m]
[WeaklyLawfulMonadAttach m] {x : m α} {a : α}, Std.Do.Internal.MayReturn x a → MonadAttach.CanReturn x a | `MayReturn` implies `MonadAttach.CanReturn` for `WeaklyLawfulMonadAttach` instances. | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.detectIte.match_4.congr_eq_1 | Std.Sat.AIG.CNF | ∀ (motive : Std.Sat.AIG.Decl ℕ → Sort u_1) (x : Std.Sat.AIG.Decl ℕ)
(h_1 : (l r : Std.Sat.AIG.Fanin) → x = Std.Sat.AIG.Decl.gate l r → motive (Std.Sat.AIG.Decl.gate l r))
(h_2 : (x_1 : Std.Sat.AIG.Decl ℕ) → x = x_1 → motive x_1) (l r : Std.Sat.AIG.Fanin)
(heq_1 : x = Std.Sat.AIG.Decl.gate l r),
(match hroot : x... | null | true |
Aesop.ForwardStateStats.noConfusionType | Aesop.Stats.Basic | Sort u → Aesop.ForwardStateStats → Aesop.ForwardStateStats → Sort u | null | false |
PseudoMetric.IsUltra | Mathlib.Topology.MetricSpace.BundledFun | {X : Type u_1} →
{R : Type u_2} → [inst : Zero R] → [inst_1 : Add R] → [inst_2 : LE R] → [Max R] → PseudoMetric X R → Prop | A pseudometric can be nonarchimedean (or ultrametric), with a stronger triangle
inequality such that `d x z ≤ max (d x y) (d y z)`. | true |
Lean.Lsp.ServerCapabilities.renameProvider?._default | Lean.Data.Lsp.Capabilities | Option Lean.Lsp.RenameOptions | null | false |
Monoid.PushoutI.NormalWord.mk.congr_simp | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} (toWord toWord_1 : Monoid.CoprodI.Word G)
(e_toWord : toWord = toWord_1) (head head_1 : H),
head = head_1 →
∀ (normalized : ∀ (i : ι) (g ... | null | true |
CategoryTheory.smallSheafify | Mathlib.CategoryTheory.Sites.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u₃) →
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] →
[inst_2 : CategoryTheory.EssentiallySmall.{w, v₁, u₁} C] →
[CategoryTheory.HasSheafify ((CategoryTheory.eq... | Transport to a small model and sheafify there. | true |
BoundedContinuousFunction.casesOn | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
{motive : BoundedContinuousFunction α β → Sort u_1} →
(t : BoundedContinuousFunction α β) →
((toContinuousMap : C(α, β)) →
(map_bounded' : ∃ C, ∀ (x y : α), dist (toCont... | null | false |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence.0.Mathlib.Tactic.Bicategory.naturality_whiskerLeft._simp_1_1 | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | ∀ {B : Type u} [self : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} {h i : b ⟶ c} (η : f ⟶ g) (θ : h ⟶ i)
{Z : a ⟶ c} (h_1 : CategoryTheory.CategoryStruct.comp g i ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η h)
(CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | false |
dvd_add_left | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b + c ↔ a ∣ b) | If an element `a` divides another element `c` in a ring, `a` divides the sum of another element
`b` with `c` iff `a` divides `b`. | true |
_private.Mathlib.Tactic.Attr.Register.0.initFn._@.Mathlib.Tactic.Attr.Register.1988518680._hygCtx._hyg.28 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.Simp.SimprocExtension | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.comp.match_1.splitter | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u_1} →
(motive : CategoryTheory.WithInitial C → CategoryTheory.WithInitial C → CategoryTheory.WithInitial C → Sort u_2) →
(x x_1 x_2 : CategoryTheory.WithInitial C) →
((_X _Y _Z : C) →
motive (CategoryTheory.WithInitial.of _X) (CategoryTheory.WithInitial.of _Y)
(CategoryTheor... | null | true |
Bundle.Trivial.symmₗ_trivialization | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B] (x : B),
Bundle.Trivialization.symmₗ 𝕜 (Bundle.Trivial.trivialization B F) x = LinearMap.id | null | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Slope.0.lineMap_slope_slope_sub_div_sub._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Slope | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] (a : G) {b c : G}, (b + a = c + a) = (b = c) | null | false |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.digits.match_1.eq_1 | Mathlib.Data.Nat.Digits.Defs | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (b : ℕ) → motive b.succ.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| b.succ.succ => h_3 b) =
h_1 () | null | true |
ArchimedeanClass.addValuation | Mathlib.Algebra.Order.Ring.Archimedean | (R : Type u_1) →
[inst : LinearOrder R] →
[inst_1 : CommRing R] → [inst_2 : IsStrictOrderedRing R] → AddValuation R (ArchimedeanClass R) | `ArchimedeanClass.mk` defines an `AddValuation` on the ring `R`. | true |
Aesop.RulePatternIndex.mk.inj | Aesop.Index.RulePattern | ∀ {tree : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry} {isEmpty : Bool}
{tree_1 : Lean.Meta.DiscrTree Aesop.RulePatternIndex.Entry} {isEmpty_1 : Bool},
{ tree := tree, isEmpty := isEmpty } = { tree := tree_1, isEmpty := isEmpty_1 } → tree = tree_1 ∧ isEmpty = isEmpty_1 | null | true |
CategoryTheory.GradedObject.BifunctorComp₂₃IndexData.mk | Mathlib.CategoryTheory.GradedObject.Trifunctor | {I₁ : Type u_7} →
{I₂ : Type u_8} →
{I₃ : Type u_9} →
{J : Type u_10} →
{r : I₁ × I₂ × I₃ → J} →
(I₂₃ : Type u_11) →
(p : I₂ × I₃ → I₂₃) →
(q : I₁ × I₂₃ → J) →
(∀ (i : I₁ × I₂ × I₃), q (i.1, p i.2) = r i) → CategoryTheory.GradedObject.BifunctorComp... | null | true |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.tendsto_iff_forall_lipschitz_integral_tendsto._simp_1_1 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{γ : Type u_2} {F : Filter γ} {μs : γ → MeasureTheory.ProbabilityMeasure Ω} {μ : MeasureTheory.ProbabilityMeasure Ω},
Filter.Tendsto μs F (nhds μ) =
∀ (f : BoundedContinuousFunction Ω ℝ),
Filter.Ten... | null | false |
FiberBundle.pullback._proof_1 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_3} {F : Type u_5} {E : B → Type u_1} {B' : Type u_2} [inst : TopologicalSpace B']
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : TopologicalSpace F] [inst_3 : TopologicalSpace B]
{K : Type u_4} [inst_4 : FunLike K B' B] [inst_5 : (x : B) → TopologicalSpace (E x)] [FiberBundle F E] (f : ... | null | false |
ENNReal.toReal.eq_1 | Mathlib.Basic.ENNReal.Basic | ∀ (a : ENNReal), a.toReal = ↑a.toNNReal | null | true |
Finset.Nonempty.nsmul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α}, s.Nonempty → ∀ {n : ℕ}, (n • s).Nonempty | null | true |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.equivHeightOneSpectrum_symm_apply_algebraMap._proof_1_5 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [inst_3 : NumberField K]
(v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K))
(w : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers L)) (x : K),
↑↑(Ideal.absNorm v.asIdeal) ^
(↑(w.asId... | null | false |
BiheytingAlgebra.toHeytingAlgebra | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : BiheytingAlgebra α] → HeytingAlgebra α | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.validAtom | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescrM String | null | true |
CompHaus.effectiveEpi_tfae | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {B X : CompHaus} (π : X ⟶ B),
[CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π,
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom π)].TFAE | null | true |
Std.Time.Day.Offset.toMilliseconds | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Millisecond.Offset | Convert `Day.Offset` into `Millisecond.Offset`.
| true |
UpperHalfPlane.num_one | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (z : UpperHalfPlane), UpperHalfPlane.num 1 ↑z = ↑z | null | true |
Std.Mutex.tryAtomically | Std.Sync.Mutex | {m : Type → Type} →
{α β : Type} → [Monad m] → [MonadLiftT BaseIO m] → [MonadFinally m] → Std.Mutex α → Std.AtomicT α m β → m (Option β) | `mutex.tryAtomically k` tries to lock `mutex` and runs `k` on it if it succeeds. On success the
return value of `k` is returned as `some`, on failure `none` is returned.
This function does not block on the `mutex`. Additionally calling `mutex.tryAtomically` while
already holding the underlying `BaseMutex` in the same ... | true |
PointedCone.maxTensorProduct | Mathlib.Geometry.Convex.Cone.TensorProduct | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : LinearOrder R] →
[inst_2 : IsStrictOrderedRing R] →
{G : Type u_2} →
[inst_3 : AddCommGroup G] →
[inst_4 : Module R G] →
{H : Type u_3} →
[inst_5 : AddCommGroup H] →
[inst_6 : Modul... | The maximal tensor product of two cones is the dual (pointed cone) of the minimal tensor product
of the dual cones. | true |
SeparationQuotient.instContinuousInv | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Inv G] [inst_2 : ContinuousInv G],
ContinuousInv (SeparationQuotient G) | null | true |
Multiset.nodup_bind._simp_1 | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} {s : Multiset α} {f : α → Multiset β},
(s.bind f).Nodup = ((∀ a ∈ s, (f a).Nodup) ∧ Multiset.Pairwise (Function.onFun Disjoint f) s) | null | false |
_private.Mathlib.Data.Num.ZNum.0.Num.gcdAux.match_1.splitter | Mathlib.Data.Num.ZNum | (motive : ℕ → Num → Num → Sort u_1) →
(x : ℕ) →
(x_1 x_2 : Num) →
((x b : Num) → motive 0 x b) →
((n : ℕ) → (b : Num) → motive n.succ Num.zero b) →
((n : ℕ) → (a b : Num) → (a = Num.zero → False) → motive n.succ a b) → motive x x_1 x_2 | null | true |
AlgebraicGeometry.GeometricallyConnected.geometrically_connectedSpace | Mathlib.AlgebraicGeometry.Geometrically.Connected | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.GeometricallyConnected f],
AlgebraicGeometry.geometrically (fun x => ConnectedSpace ↥x) f | null | true |
Lean.Lsp.SemanticTokenType.leanSorryLike.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.leanSorryLike = 1 | null | true |
Finmap.mem_singleton | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (x y : α) (b : β y), x ∈ Finmap.singleton y b ↔ x = y | null | true |
FractionalIdeal.instMin | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_1} →
[inst : CommRing R] →
{S : Submonoid R} → {P : Type u_2} → [inst_1 : CommRing P] → [inst_2 : Algebra R P] → Min (FractionalIdeal S P) | null | true |
nonZeroSMulDivisors.«_aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___macroRules_nonZeroSMulDivisors_term_⁰[_]_1» | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | Lean.Macro | null | false |
Bundle.Pretrivialization.domExtend._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_1} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
{s : Set B} (e : Bundle.Pretrivialization F fun z => proj ↑z) [inst_2 : Nonempty (Z → F)],
∀ x ∈ Subtype.val '' e.source,
(if h : proj x ∈ s then ↑e ⟨x, h⟩ else (proj x, Classical.arbitrary (Z... | null | false |
MonoidAlgebra.opRingEquiv_single | Mathlib.Algebra.MonoidAlgebra.Opposite | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : Mul M] (r : R) (x : M),
MonoidAlgebra.opRingEquiv (MulOpposite.op (MonoidAlgebra.single x r)) =
MonoidAlgebra.single (MulOpposite.op x) (MulOpposite.op r) | null | true |
Set.prod_pow._f | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] (s : Set α) (t : Set β) (x : ℕ) (f : Nat.below x),
s ×ˢ t ^ x = (s ^ x) ×ˢ (t ^ x) | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.pushColumn | Lean.DocString.Parser | Lean.Parser.ParserFn | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.CyclotomicUnits.0.IsPrimitiveRoot.associated_pow_sub_one_pow_of_coprime._proof_1_1 | Mathlib.RingTheory.RootsOfUnity.CyclotomicUnits | ∀ {n i j : ℕ} {A : Type u_1} {ζ : A} [inst : CommRing A],
i.Coprime n →
j.Coprime n → (∀ {j : ℕ}, j.Coprime n → Associated (ζ - 1) (ζ ^ j - 1)) → Associated (ζ ^ j - 1) (ζ ^ i - 1) | null | false |
Ordinal.one_lt_opow._simp_1 | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b : Ordinal.{u_1}}, (1 < a ^ b) = (1 < a ∧ b ≠ 0) | null | false |
Sylow.exists_subgroup_le_card_pow_prime_of_le_card | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] {n p : ℕ},
Nat.Prime p → IsPGroup p G → ∀ {H : Subgroup G}, p ^ n ≤ Nat.card ↥H → ∃ H' ≤ H, Nat.card ↥H' = p ^ n | A special case of **Sylow's first theorem**. If `G` is a `p`-group and `H` a subgroup of size at
least `p ^ n` then there is a subgroup of `H` of cardinality `p ^ n`. | true |
Lean.Parser.Tactic.tacticTry_ | Init.Tactics | Lean.ParserDescr | `try tac` runs `tac` and succeeds even if `tac` failed. | true |
OrderRingIso.ext | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Add α] [inst_2 : LE α] [inst_3 : Mul β] [inst_4 : Add β]
[inst_5 : LE β] {f g : α ≃+*o β}, (∀ (a : α), f a = g a) → f = g | null | true |
CategoryTheory.Mat_.embedding | Mathlib.CategoryTheory.Preadditive.Mat | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Preadditive C] → CategoryTheory.Functor C (CategoryTheory.Mat_ C) | The embedding of `C` into `Mat_ C` as one-by-one matrices.
(We index the summands by `PUnit`.) | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.mem_multisetInfinitePlace._simp_1_3 | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] (v : AbsoluteValue K ℝ), NumberField.IsInfinitePlace v = ∃ w, ↑w = v | null | false |
CategoryTheory.SmallObject.functorMapTgt | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
(f : (i : I) → A i ⟶ B i) →
{S T X Y : C} →
{πX : X ⟶ S} →
{πY : Y ⟶ T} →
(CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY) →
[inst_... | The canonical morphism `∐ functorObjTgtFamily f πX ⟶ ∐ functorObjTgtFamily f πY`
induced by a morphism `Arrow.mk πX ⟶ Arrow.mk πY`. | true |
CategoryTheory.Pseudofunctor.mapComp'_id_comp_inv_app | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
(F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {b₀ b₁ : B} (f : b₀ ⟶ b₁) (X : ↑(F.obj b₀)),
(F.mapComp' (CategoryTheory.CategoryStruct.id b₀) f f ⋯).inv.toNatTrans.app X =
(F.map f).toFunctor.map ((F.map... | null | true |
_private.Batteries.Recycling.RBTree.Basic.0.RBTree.RBNode.All.imp.match_1_1 | Batteries.Recycling.RBTree.Basic | ∀ {α : Type u_1} {p : α → Prop} (c : RBTree.RBColor) (l : RBTree.RBNode α) (v : α) (r : RBTree.RBNode α)
(motive : RBTree.RBNode.All p (RBTree.RBNode.node c l v r) → Prop)
(x : RBTree.RBNode.All p (RBTree.RBNode.node c l v r)),
(∀ (h : p v) (hl : RBTree.RBNode.All p l) (hr : RBTree.RBNode.All p r), motive ⋯) → mo... | null | false |
Std.Http.Server.shutdown | Std.Http.Server | Std.Http.Server → Std.Async.Async Unit | Triggers cancellation of all requests and the accept loop in the server. This function should be used
in conjunction with `waitShutdown` to properly coordinate the shutdown sequence.
| true |
Option.not_lt_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : Option α}, ¬a < none | null | true |
Relation.ReflTransGen.symmetric | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Symm r], Std.Symm (Relation.ReflTransGen r) | **Alias** of `Relation.ReflTransGen.stdSymm`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.