name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_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.IterStep.skip it with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it => h_2 it
| Std.IterStep.done => h_3 ()) =
h_2 it | 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 | false |
csInf_singleton | Mathlib.Order.ConditionallyCompletePartialOrder.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderInf α] (a : α), sInf {a} = a | 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 | false |
ωCPO.ctorIdx | Mathlib.Order.Category.OmegaCompletePartialOrder | ωCPO → ℕ | 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 | 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.CategoryStruct.comp (X.δ f₂ f₃ n₀ n₁ ⋯) (X.δ f₁ f₂ n₁ (n₁ + 1) ⋯) = 0 | 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 | 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) | 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 | 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 m R M₂),
(Matrix.toLin v₁ v₂).symm = LinearMap.toMatrix v₁ v₂ | 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 | 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 | 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) | false |
AddGroupTopology.toTopologicalSpace_le | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u} [inst : AddGroup α] {x y : AddGroupTopology α}, x.toTopologicalSpace ≤ y.toTopologicalSpace ↔ x ≤ y | true |
AlgebraicGeometry.IsIntegralHom.integral_app | Mathlib.AlgebraicGeometry.Morphisms.Integral | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [self : AlgebraicGeometry.IsIntegralHom f] (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).IsIntegral | 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) | 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 | true |
Lean.JsonRpc.ErrorCode.workerCrashed | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode | 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 : M →ₛₗ[σ₁₂] M₂)
(g : M₂ →ₛₗ[σ₂₁] M) {h₁ : f ∘ₛₗ g = LinearMap.id} {h₂ : g ∘ₛₗ f = LinearMap.id}, ↑(LinearEquiv.ofLinear f g h₁ h₂) = f | true |
mul_left_inj._simp_2 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Mul G] [IsRightCancelMul G] (a : G) {b c : G}, (b * a = c * a) = (b = c) | false |
Lean.ScopedEnvExtension.Descr.toOLeanEntry | Lean.ScopedEnvExtension | {α β σ : Type} → Lean.ScopedEnvExtension.Descr α β σ → β → α | 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 | true |
Lean.Meta.introSubstEq | Lean.Meta.Tactic.Subst | Lean.MVarId → optParam Bool false → Lean.MetaM (Lean.Meta.FVarSubst × Lean.MVarId) | true |
Batteries.RBNode.Ordered.upperBound?_exists | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : Batteries.RBNode α} [Std.TransCmp cmp]
[Batteries.RBNode.IsCut cmp cut],
Batteries.RBNode.Ordered cmp t → ((∃ x, Batteries.RBNode.upperBound? cut t = some x) ↔ ∃ x ∈ t, cut x ≠ Ordering.gt) | true |
Aesop.ForwardStateStats.noConfusionType | Aesop.Stats.Basic | Sort u → Aesop.ForwardStateStats → Aesop.ForwardStateStats → Sort u | 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 | true |
Lean.Lsp.ServerCapabilities.renameProvider?._default | Lean.Data.Lsp.Capabilities | Option Lean.Lsp.RenameOptions | 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 : G i), ⟨i, g⟩ ∈ toWord.toList → g ∈ d.set i),
{ toWord := toWord, head := head, normalized := normalized } =
{ toWord := toWord_1, head := head_1, normalized := ⋯ } | 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.equivSmallModel C).inverse.inducedTopology J) A] →
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ A) (CategoryTheory.Sheaf J A) | true |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_12 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (n : ℕ),
(∀ (k : ℕ) (hk : k < n), (CoxeterSystem.alternatingWord i j n)[k] = if Even (n + k) then i else j) →
∀ (k : ℕ) (h : k < n + 1), (CoxeterSystem.alternatingWord i j (n + 1))[k] = if Even (n + 1 + k) then i else j | false |
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 (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C) →
motive { toContinuousMap := toContinuousMap, map_bounded' := map_bounded' }) →
motive t | 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 (CategoryTheory.Bicategory.whiskerLeft g θ) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft f θ)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η i) h_1) | false |
dvd_add_left | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b + c ↔ a ∣ b) | 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 | true |
_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)
(CategoryTheory.WithInitial.of _Z)) →
((x : CategoryTheory.WithInitial C) →
(_X : C) → motive CategoryTheory.WithInitial.star x (CategoryTheory.WithInitial.of _X)) →
((x : CategoryTheory.WithInitial C) →
(_X : C) → motive x (CategoryTheory.WithInitial.of _X) CategoryTheory.WithInitial.star) →
((_Y : C) →
(x : CategoryTheory.WithInitial C) →
motive (CategoryTheory.WithInitial.of _Y) CategoryTheory.WithInitial.star x) →
(Unit →
motive CategoryTheory.WithInitial.star CategoryTheory.WithInitial.star
CategoryTheory.WithInitial.star) →
motive x x_1 x_2 | 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) | 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 () | 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) | 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 | 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₂₃IndexData r | 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.Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (nhds (∫ (ω : Ω), f ω ∂↑μ)) | 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 : K)
(x : B'), Topology.IsInducing (Bundle.TotalSpace.mk x) | false |
ENNReal.toReal.eq_1 | Mathlib.Data.ENNReal.Basic | ∀ (a : ENNReal), a.toReal = ↑a.toNNReal | 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 | true |
BiheytingAlgebra.toHeytingAlgebra | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : BiheytingAlgebra α] → HeytingAlgebra α | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.validAtom | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescrM String | true |
CompHaus.effectiveEpi_tfae | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {B X : CompHaus} (π : X ⟶ B),
[CategoryTheory.EffectiveEpi π, CategoryTheory.Epi π,
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom π)].TFAE | true |
Std.Time.Day.Offset.toMilliseconds | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Millisecond.Offset | 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 β) | 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 : Module R H] → PointedCone R G → PointedCone R H → PointedCone R (TensorProduct R G H) | true |
StateRefT'.instMonadAttachOfMonad._aux_3 | Init.Control.StateRef | {ω σ : Type} →
{m : Type → Type} →
[Monad m] →
[inst : MonadAttach m] →
{α : Type} → (x : StateRefT' ω σ m α) → StateRefT' ω σ m (Subtype (StateRefT'.instMonadAttachOfMonad._aux_1 x)) | false |
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) | 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) | 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 | true |
Lean.Lsp.SemanticTokenType.leanSorryLike.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.leanSorryLike = 1 | true |
Lean.Server.Test.Refs.Test6.rec | Lean.Server.Test.Refs | {motive : Lean.Server.Test.Refs.Test6 → Sort u} →
motive Lean.Server.Test.Refs.Test6.mk → (t : Lean.Server.Test.Refs.Test6) → motive t | false |
Finmap.mem_singleton | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (x y : α) (b : β y), x ∈ Finmap.singleton y b ↔ x = y | 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) | true |
nonZeroSMulDivisors.«_aux_Mathlib_Algebra_GroupWithZero_NonZeroDivisors___macroRules_nonZeroSMulDivisors_term_⁰[_]_1» | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | Lean.Macro | 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 → F) x)) ∈ e.target | 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) | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.pushColumn | Lean.DocString.Parser | Lean.Parser.ParserFn | 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) | false |
Ordinal.one_lt_opow._simp_1 | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b : Ordinal.{u_1}}, (1 < a ^ b) = (1 < a ∧ b ≠ 0) | 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 | true |
Lean.Parser.Tactic.tacticTry_ | Init.Tactics | Lean.ParserDescr | 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 | 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) | 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 | 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_1 :
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C] →
[inst_2 :
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πY)) C] →
∐ CategoryTheory.SmallObject.functorObjTgtFamily f πX ⟶
∐ CategoryTheory.SmallObject.functorObjTgtFamily f π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 =
CategoryTheory.CategoryStruct.comp ((F.map f).toFunctor.map ((F.mapId b₀).hom.toNatTrans.app X))
(CategoryTheory.eqToHom ⋯) | true |
_private.Batteries.Data.AssocList.0.Batteries.AssocList.beq.match_1.eq_4 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2} (motive : Batteries.AssocList α β → Batteries.AssocList α β → Sort u_3) (a : α) (b : β)
(t : Batteries.AssocList α β) (a' : α) (b' : β) (t' : Batteries.AssocList α β)
(h_1 : Unit → motive Batteries.AssocList.nil Batteries.AssocList.nil)
(h_2 :
(key : α) →
(value : β) →
(tail : Batteries.AssocList α β) → motive (Batteries.AssocList.cons key value tail) Batteries.AssocList.nil)
(h_3 :
(key : α) →
(value : β) →
(tail : Batteries.AssocList α β) → motive Batteries.AssocList.nil (Batteries.AssocList.cons key value tail))
(h_4 :
(a : α) →
(b : β) →
(t : Batteries.AssocList α β) →
(a' : α) →
(b' : β) →
(t' : Batteries.AssocList α β) →
motive (Batteries.AssocList.cons a b t) (Batteries.AssocList.cons a' b' t')),
(match Batteries.AssocList.cons a b t, Batteries.AssocList.cons a' b' t' with
| Batteries.AssocList.nil, Batteries.AssocList.nil => h_1 ()
| Batteries.AssocList.cons key value tail, Batteries.AssocList.nil => h_2 key value tail
| Batteries.AssocList.nil, Batteries.AssocList.cons key value tail => h_3 key value tail
| Batteries.AssocList.cons a b t, Batteries.AssocList.cons a' b' t' => h_4 a b t a' b' t') =
h_4 a b t a' b' t' | true |
Option.not_lt_none | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : Option α}, ¬a < none | true |
Relation.ReflTransGen.symmetric | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop}, Symmetric r → Symmetric (Relation.ReflTransGen r) | true |
CategoryTheory.Limits.BinaryBicone.isLimitFstKernelFork._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {c : CategoryTheory.Limits.BinaryBicone X Y} (s : CategoryTheory.Limits.Fork c.fst 0)
{m :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj c.fstKernelFork.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero},
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.Fork.ι c.fstKernelFork) = s.ι →
m = CategoryTheory.CategoryStruct.comp s.ι c.snd | false |
_private.Mathlib.Data.List.Sort.0.List.sortedLT_iff_pairwise._proof_1_5 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} (w : ℕ) (w_2 : w + 1 ≤ l.length), ↑⟨w, ⋯⟩ < l.length | false |
Polynomial.algEquivAevalXAddC._proof_1 | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u_1} [inst : CommRing R] (t : R),
(Polynomial.X + Polynomial.C t).comp (Polynomial.X - Polynomial.C t) = Polynomial.X | false |
Lean.Compiler.LCNF.Simp.markSimplified | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.SimpM Unit | true |
AlgebraicGeometry.Scheme.Pullback.diagonalCover.eq_1 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).X i).OpenCover),
AlgebraicGeometry.Scheme.Pullback.diagonalCover f 𝒰 𝒱 =
CategoryTheory.Precoverage.ZeroHypercover.bind (AlgebraicGeometry.Scheme.Pullback.openCoverOfBase 𝒰 f f) fun i =>
AlgebraicGeometry.Scheme.Pullback.openCoverOfLeftRight (𝒱 i) (𝒱 i)
(AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 f i) (AlgebraicGeometry.Scheme.Cover.pullbackHom 𝒰 f i) | true |
NonUnitalStarAlgHom.instZero._proof_2 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : StarAddMonoid A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : StarAddMonoid B] (a : A),
(NonUnitalAlgHom.toDistribMulActionHom 0).toFun (star a) = star ((NonUnitalAlgHom.toDistribMulActionHom 0).toFun a) | false |
Lean.Export.instCoeLevelEntry | Mathlib.Util.Export | Coe Lean.Level Lean.Export.Entry | true |
PowerSeries.isUnit_exp | Mathlib.RingTheory.PowerSeries.Exp | ∀ (A : Type u_4) [inst : Ring A] [inst_1 : Algebra ℚ A], IsUnit (PowerSeries.exp A) | true |
CommRingCat.Colimits.quot_mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x y : CommRingCat.Colimits.Prequotient F),
Quot.mk (⇑(CommRingCat.Colimits.colimitSetoid F)) (x.mul y) =
(have this := Quot.mk (⇑(CommRingCat.Colimits.colimitSetoid F)) x;
this) *
have this := Quot.mk (⇑(CommRingCat.Colimits.colimitSetoid F)) y;
this | true |
CategoryTheory.Limits.FormalCoproduct.mapPower_π_assoc | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Limits.FormalCoproduct C) {α β : Type}
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C] [inst_2 : CategoryTheory.Limits.HasProductsOfShape β C]
(f : α → β) (a : α) {Z : CategoryTheory.Limits.FormalCoproduct C} (h : U ⟶ Z),
CategoryTheory.CategoryStruct.comp (U.mapPower f) (CategoryTheory.CategoryStruct.comp (U.powerπ a) h) =
CategoryTheory.CategoryStruct.comp (U.powerπ (f a)) h | true |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_49 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (q : Turing.PartrecToTM2.Λ') (p : Turing.PartrecToTM2.Γ' → Bool) (k₁ k₂ : Turing.PartrecToTM2.K')
(q_1 : Turing.PartrecToTM2.Λ'), q.succ = Turing.PartrecToTM2.Λ'.move p k₁ k₂ q_1 → False | false |
CategoryTheory.Functor.commShiftIso_inv_naturality | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : F.CommShift A] {X Y : C}
(f : X ⟶ Y) (a : A),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D a).map (F.map f))
((CategoryTheory.Functor.commShiftIso F a).inv.app Y) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.commShiftIso F a).inv.app X)
(F.map ((CategoryTheory.shiftFunctor C a).map f)) | true |
Equiv.divisionRing._proof_8 | Mathlib.Algebra.Field.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : DivisionRing β] (x y : α), e (e.symm (e x / e y)) = e x / e y | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.structuresPass.postprocess.match_6 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures | (motive : Lean.Meta.Simprocs × Lean.Meta.SimpTheoremsArray → Sort u_1) →
(__discr : Lean.Meta.Simprocs × Lean.Meta.SimpTheoremsArray) →
((simprocs : Lean.Meta.Simprocs) →
(relevantLemmas : Lean.Meta.SimpTheoremsArray) → motive (simprocs, relevantLemmas)) →
motive __discr | false |
Semiring.toGrindSemiring.match_1 | Mathlib.Algebra.Ring.GrindInstances | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | false |
SubalgebraClass.seminormedRing._proof_16 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : SeminormedRing E] [inst_1 : SetLike S E] [inst_2 : SubringClass S E] (s : S)
(n : ℕ) (a : ↥s), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isDefEqEta._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.Grind.Arith.Linear.Search.State.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Linear.Search.State} →
t = t' → Lean.Meta.Grind.Arith.Linear.Search.State.noConfusionType P t t' | false |
Nat.primeFactors_subset_of_mem_smoothNumbers | Mathlib.NumberTheory.SmoothNumbers | ∀ {m n : ℕ}, m ∈ n.smoothNumbers → m.primeFactors ⊆ n.primesBelow | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.processNewIntDiseq | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit | true |
Fin.Embedding.coe_cons | Mathlib.Data.Fin.Tuple.Embedding | ∀ {α : Type u_1} {n : ℕ} (x : Fin n ↪ α) {a : α} (ha : a ∉ Set.range ⇑x), ⇑(Fin.Embedding.cons x ha) = Fin.cons a ⇑x | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.noConfusionType | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | Sort u_1 →
{C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →
{data : F.OneHypercoverDenseData J₀ J X} →
{X₀ : C₀} →
{f : F.obj X₀ ⟶ X} →
{Y₀ : C₀} →
{g : Y₀ ⟶ X₀} →
data.SieveStruct f g →
{C₀' : Type u₀} →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v₀, u₀} C₀'] →
[inst'_1 : CategoryTheory.Category.{v, u} C'] →
{F' : CategoryTheory.Functor C₀' C'} →
{J₀' : CategoryTheory.GrothendieckTopology C₀'} →
{J' : CategoryTheory.GrothendieckTopology C'} →
{X' : C'} →
{data' : F'.OneHypercoverDenseData J₀' J' X'} →
{X₀' : C₀'} →
{f' : F'.obj X₀' ⟶ X'} →
{Y₀' : C₀'} → {g' : Y₀' ⟶ X₀'} → data'.SieveStruct f' g' → Sort u_1 | false |
Std.TreeMap.size_add_size_eq_size_union_add_size_inter | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t₁.size + t₂.size = (t₁ ∪ t₂).size + (t₁ ∩ t₂).size | true |
_private.Mathlib.Data.Set.Pairwise.Basic.0.Set.injOn_iff_pairwise_ne._simp_1_2 | Mathlib.Data.Set.Pairwise.Basic | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | false |
CategoryTheory.e_assoc' | Mathlib.CategoryTheory.Enriched.Basic | ∀ (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] (W X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (W ⟶[V] X) (X ⟶[V] Y) (Y ⟶[V] Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (W ⟶[V] X) (CategoryTheory.eComp V X Y Z))
(CategoryTheory.eComp V W X Z)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.eComp V W X Y) (Y ⟶[V] Z))
(CategoryTheory.eComp V W Y Z) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.