name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ProbabilityTheory.IndepFun.process_indepFun_process₀ | Mathlib.Probability.Independence.Process.Basic | ∀ {S : Type u_1} {Ω : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {T : Type u_4} {𝓧 : S → Type u_5}
{𝓨 : T → Type u_6} [inst : (i : S) → MeasurableSpace (𝓧 i)] [inst_1 : (j : T) → MeasurableSpace (𝓨 j)]
{X : (i : S) → Ω → 𝓧 i} {Y : (j : T) → Ω → 𝓨 j},
(∀ (i : S), AEMeasurable (X i) P) →
(∀ (j : T), AEMeasurable (Y j) P) →
(∀ (I : Finset S) (J : Finset T), ProbabilityTheory.IndepFun (fun ω i => X (↑i) ω) (fun ω j => Y (↑j) ω) P) →
∀ [MeasureTheory.IsZeroOrProbabilityMeasure P],
ProbabilityTheory.IndepFun (fun ω i => X i ω) (fun ω j => Y j ω) P | true |
Equiv.Perm.isThreeCycle_swap_mul_swap_same | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {a b c : α},
a ≠ b → a ≠ c → b ≠ c → (Equiv.swap a b * Equiv.swap a c).IsThreeCycle | true |
Lean.Parser.Command.eval | Lean.Parser.Command | Lean.Parser.Parser | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.allCombinations.go.eq_def | Lean.Elab.PreDefinition.Structural.FindRecArg | ∀ {α : Type u_1} (xss : Array (Array α)) (i : ℕ) (acc : Array α),
Lean.Elab.Structural.allCombinations.go✝ xss i acc =
if h : i < xss.size then
Array.flatMap (fun x => Lean.Elab.Structural.allCombinations.go✝¹ xss (i + 1) (acc.push x)) xss[i]
else #[acc] | true |
ZMod.intCast_cast_add | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (x y : ZMod n), (x + y).cast = (x.cast + y.cast) % ↑n | true |
CategoryTheory.Pretriangulated.unop_distinguished | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles | true |
WeierstrassCurve.Affine.polynomial_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] {W : WeierstrassCurve.Affine R} [Nontrivial R], W.polynomial ≠ 0 | true |
_private.Mathlib.RingTheory.Localization.FractionRing.0.IsFractionRing.fieldEquivOfAlgEquiv._simp_2 | Mathlib.RingTheory.Localization.FractionRing | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
CategoryTheory.ComposableArrows.map'_comp._auto_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | false |
Batteries.PairingHeap.ofList | Batteries.Data.PairingHeap | {α : Type u} → (le : α → α → Bool) → List α → Batteries.PairingHeap α le | true |
Irreducible.prime | Mathlib.Algebra.Prime.Defs | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [DecompositionMonoid M] {a : M}, Irreducible a → Prime a | true |
Lean.Elab.instLEHoverableInfoPrio | Lean.Server.InfoUtils | LE Lean.Elab.HoverableInfoPrio | true |
NonemptyInterval.fst_mul | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : Mul α] [inst_2 : MulLeftMono α] [inst_3 : MulRightMono α]
(s t : NonemptyInterval α), (s * t).toProd.1 = s.toProd.1 * t.toProd.1 | true |
List.next_eq_getElem | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α} (ha : a ∈ l),
l.next a ha = l[(List.idxOf a l + 1) % l.length] | true |
ZSpan.fract_fract | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (m : E), ZSpan.fract b (ZSpan.fract b m) = ZSpan.fract b m | true |
CategoryTheory.uliftYoneda_obj_map | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) {X_1 Y : Cᵒᵖ} (f : X_1 ⟶ Y)
(a : CategoryTheory.uliftFunctor.{w, v₁}.obj ((CategoryTheory.yoneda.obj X).obj X_1)),
(CategoryTheory.uliftYoneda.{w, v₁, u₁}.obj X).map f a = { down := CategoryTheory.CategoryStruct.comp f.unop a.down } | true |
CategoryTheory.Limits.Cocone.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {j j' : J} (f : j' ⟶ j) {Z : C} (h : c.pt ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (c.ι.app j) h) =
CategoryTheory.CategoryStruct.comp (c.ι.app j') h | true |
ModuleCat.semilinearMapAddEquiv._proof_5 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (M : ModuleCat R) (N : ModuleCat S),
Function.RightInverse (fun g => { toFun := ⇑(CategoryTheory.ConcreteCategory.hom g), map_add' := ⋯, map_smul' := ⋯ })
fun g => ModuleCat.ofHom { toFun := ⇑g, map_add' := ⋯, map_smul' := ⋯ } | false |
Finset.commMonoid.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : CommMonoid α],
Finset.commMonoid = Function.Injective.commMonoid SetLike.coe ⋯ ⋯ ⋯ ⋯ | true |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.embDomain_le_embDomain_iff_le._simp_1_1 | Mathlib.Data.Finsupp.Order | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : LE M] {f g : ι →₀ M}, (f ≤ g) = ∀ (i : ι), f i ≤ g i | false |
_private.Mathlib.Algebra.BigOperators.WithTop.0.WithTop.prod_eq_top._simp_1_1 | Mathlib.Algebra.BigOperators.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | false |
continuousAt_matrix_inv | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
[inst_3 : CommRing R] [IsTopologicalRing R] (A : Matrix n n R),
ContinuousAt Ring.inverse A.det → ContinuousAt Inv.inv A | true |
_private.Mathlib.Analysis.MeanInequalities.0.NNReal.Lr_le_Lp_mul_Lq._simp_1_4 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
Std.DTreeMap.Internal.Impl.foldlM | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type u_1} → [Monad m] → (δ → (a : α) → β a → m δ) → δ → Std.DTreeMap.Internal.Impl α β → m δ | true |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.wSameSide_self_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_2} {V : Type u_3} {P : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] {s : AffineSubspace R P} (motive : (↑s).Nonempty → Prop) (x : (↑s).Nonempty),
(∀ (p : P) (hp : p ∈ ↑s), motive ⋯) → motive x | false |
MulAction.equivSubgroupOrbitsSetoidComap._proof_10 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : MulAction α β] (H : Subgroup α)
(ω : Quotient (MulAction.orbitRel α β)),
Function.RightInverse (fun q => q.liftOn' (fun x => ⟦⟨↑x, ⋯⟩⟧) ⋯) fun q => Quotient.liftOn' q (fun x => ⟦⟨↑x, ⋯⟩⟧) ⋯ | false |
Subsemiring.subtype_apply | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {s : Subsemiring R} (x : ↥s), s.subtype x = ↑x | true |
NonUnitalSubsemiring.instInhabited | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} → [inst : NonUnitalNonAssocSemiring R] → Inhabited (NonUnitalSubsemiring R) | true |
Nat.dist_cast_real | Mathlib.Topology.Instances.Nat | ∀ (x y : ℕ), dist ↑x ↑y = dist x y | true |
UInt32.add_right_inj._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt32} (c : UInt32), (c + a = c + b) = (a = b) | false |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (natStructId : ℕ) (lhs rhs : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr)
(natStructId_1 : ℕ) (lhs_1 rhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat a b natStructId lhs rhs =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat a_1 b_1 natStructId_1 lhs_1 rhs_1) =
(a = a_1 ∧ b = b_1 ∧ natStructId = natStructId_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1) | true |
LocallyConstant.charFn_eq_one | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : MulZeroOneClass Y] {U : Set X} [Nontrivial Y]
(x : X) (hU : IsClopen U), (LocallyConstant.charFn Y hU) x = 1 ↔ x ∈ U | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogConfig.ofLspLogConfig._sparseCasesOn_1 | Lean.Server.Logging | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Split | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
MulAction.IsPretransitive.t1Space_iff | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} (G : Type u_4) [inst : TopologicalSpace α] [inst_1 : Group G] [inst_2 : MulAction G α]
[ContinuousConstSMul G α] (x : α) [MulAction.IsPretransitive G α], T1Space α ↔ IsClosed {x} | true |
FreeAddMonoid.length_eq_one | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {a : FreeAddMonoid α}, a.length = 1 ↔ ∃ m, a = FreeAddMonoid.of m | true |
PNat.instSuccAddOrder._proof_1 | Mathlib.Data.PNat.Order | ∀ (x : ℕ+), SuccOrder.succ x = SuccOrder.succ x | false |
_private.Mathlib.Analysis.MellinInversion.0.rexp_cexp_aux._simp_1_1 | Mathlib.Analysis.MellinInversion | (0 < Real.pi) = True | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Induction.0.Lean.Elab.PartialFixpoint.isPartialCorrectnessName.match_1 | Lean.Elab.PreDefinition.PartialFixpoint.Induction | (motive : String → Sort u_1) →
(s : String) →
(Unit → motive "partial_correctness") →
(Unit → motive "mutual_partial_correctness") → ((x : String) → motive x) → motive s | false |
Lean.Meta.Tactic.Cbv.CbvTheoremsLookupState.mk.inj | Lean.Meta.Tactic.Cbv.TheoremsLookup | ∀ {eqnTheorems : Lean.PHashMap Lean.Name Lean.Meta.Sym.Simp.Theorems}
{unfoldTheorems : Lean.PHashMap Lean.Name Lean.Meta.Sym.Simp.Theorem}
{matchTheorems eqnTheorems_1 : Lean.PHashMap Lean.Name Lean.Meta.Sym.Simp.Theorems}
{unfoldTheorems_1 : Lean.PHashMap Lean.Name Lean.Meta.Sym.Simp.Theorem}
{matchTheorems_1 : Lean.PHashMap Lean.Name Lean.Meta.Sym.Simp.Theorems},
{ eqnTheorems := eqnTheorems, unfoldTheorems := unfoldTheorems, matchTheorems := matchTheorems } =
{ eqnTheorems := eqnTheorems_1, unfoldTheorems := unfoldTheorems_1, matchTheorems := matchTheorems_1 } →
eqnTheorems = eqnTheorems_1 ∧ unfoldTheorems = unfoldTheorems_1 ∧ matchTheorems = matchTheorems_1 | true |
Std.DTreeMap.Raw.isEmpty_emptyc | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}, ∅.isEmpty = true | true |
ArithmeticFunction.instSemiring._proof_2 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Semiring R] (a b c : ArithmeticFunction R), a * (b + c) = a * b + a * c | false |
Lean.Elab.Term.Do.Code.continue.inj | Lean.Elab.Do.Legacy | ∀ {ref ref_1 : Lean.Syntax}, Lean.Elab.Term.Do.Code.continue ref = Lean.Elab.Term.Do.Code.continue ref_1 → ref = ref_1 | true |
contMDiffWithinAt_one | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E']
{H' : Type u_6} [inst_7 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7}
[inst_8 : TopologicalSpace M'] [inst_9 : ChartedSpace H M] [inst_10 : ChartedSpace H' M'] {s : Set M} {x : M}
{n : WithTop ℕ∞} [inst_11 : One M'], ContMDiffWithinAt I I' n 1 s x | true |
Algebra.PreSubmersivePresentation.algebra._inherited_default | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
{inst : CommRing R} → {inst_1 : CommRing S} → {inst_2 : Algebra R S} → (ι → S) → Algebra (MvPolynomial ι R) S | false |
Lean.Elab.Tactic.setGrindParams | Lean.Elab.Tactic.Grind.Main | Lean.TSyntax `tactic → Array Lean.Syntax → Lean.TSyntax `tactic | true |
Mathlib.Tactic.FieldSimp.Sign.ctorElimType | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} → {M : Q(Type v)} → {motive : Mathlib.Tactic.FieldSimp.Sign M → Sort u} → ℕ → Sort (max 1 u) | false |
Lean.Language.SnapshotTask.ReportingRange.ctorIdx | Lean.Language.Basic | Lean.Language.SnapshotTask.ReportingRange → ℕ | false |
withBotSucc_one | Mathlib.Data.Nat.SuccPred | WithBot.succ 1 = 2 | true |
Matroid.eq_freeOn_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α} {E : Set α}, M = Matroid.freeOn E ↔ M.E = E ∧ M.Indep E | true |
_private.Mathlib.Topology.ClusterPt.0.accPt_iff_frequently._simp_1_2 | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X},
ClusterPt x (Filter.principal s) = ∃ᶠ (y : X) in nhds x, y ∈ s | false |
StarAlgEquiv.aut._proof_5 | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (n : ℕ)
(a : R ≃⋆ₐ[S] R), zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a | false |
ApproximatesLinearOn.toOpenPartialHomeomorph_coe | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} (s : Set E) {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (↑f') s c)
(hc : Subsingleton E ∨ c < ‖↑f'.symm‖₊⁻¹) (hs : IsOpen s),
↑(ApproximatesLinearOn.toOpenPartialHomeomorph f s hf hc hs) = f | true |
AlgebraicGeometry.Scheme.IdealSheafData.instOrderBot._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (⊥ U) = ⊥ (X.affineBasicOpen f) | false |
Lean.Grind.GrobnerConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.GrobnerConfig → Lean.Grind.GrobnerConfig → Sort u | false |
AddOpposite.instGroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [Group α] → Group αᵃᵒᵖ | true |
Lean.Core.SavedState._sizeOf_1 | Lean.CoreM | Lean.Core.SavedState → ℕ | false |
_private.Mathlib.Geometry.Euclidean.Similarity.0.Similar.angle_eq._proof_1_3 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {b c : P₁} {b' c' : P₂} (r : ℝ),
dist c b = r * dist c' b' → dist c' b' = 0 → dist c b = 0 | false |
RingCat.Colimits.descMorphism._proof_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(s : CategoryTheory.Limits.Cocone F) (x y : RingCat.Colimits.ColimitType F),
RingCat.Colimits.descFun F s (x * y) = RingCat.Colimits.descFun F s x * RingCat.Colimits.descFun F s y | false |
AlgebraicGeometry.LocallyRingedSpace.coproductCofanIsColimit | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.HasColimits | {ι : Type v} →
[inst : Small.{u, v} ι] →
(F : CategoryTheory.Functor (CategoryTheory.Discrete ι) AlgebraicGeometry.LocallyRingedSpace) →
CategoryTheory.Limits.IsColimit (AlgebraicGeometry.LocallyRingedSpace.coproductCofan F) | true |
_private.Lean.Meta.Tactic.Grind.CollectParams.0.Lean.Meta.Grind.Collector.collect._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.CollectParams | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Submodule.reflection_trans_reflection | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection],
K.reflection.trans K.reflection = LinearIsometryEquiv.refl 𝕜 E | true |
CategoryTheory.MonoidalCategory.leftUnitor_tensor_hom''_assoc | Mathlib.CategoryTheory.Monoidal.CoherenceLemmas | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
{Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X Y).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom
(CategoryTheory.CategoryStruct.id Y))
h | true |
leftAddCoset_eq_iff | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {x y : α}, x +ᵥ ↑s = y +ᵥ ↑s ↔ -x + y ∈ s | true |
Std.DTreeMap.Raw.Const.get!_filter' | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited β] {f : α → β → Bool} {k : α},
t.WF →
Std.DTreeMap.Raw.Const.get! (Std.DTreeMap.Raw.filter f t) k =
(Option.filter (f k) (Std.DTreeMap.Raw.Const.get? t k)).get! | true |
EuclideanGeometry.preimage_inversion_sphere_dist_center | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c y : P} {R : ℝ},
R ≠ 0 →
y ≠ c →
EuclideanGeometry.inversion c R ⁻¹' Metric.sphere y (dist y c) =
insert c ↑(AffineSubspace.perpBisector c (EuclideanGeometry.inversion c R y)) | true |
Lean.Doc.Data.ConvTactic._sizeOf_inst | Lean.Elab.DocString.Builtin | SizeOf Lean.Doc.Data.ConvTactic | false |
NonUnitalSubalgebra.center_eq_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_3) [inst_1 : NonUnitalCommSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A], NonUnitalSubalgebra.center R A = ⊤ | true |
CategoryTheory.Bicategory.whiskerRight_congr._proof_1 | Mathlib.CategoryTheory.Bicategory.EqToHom | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {y z : B} {g g' : y ⟶ z},
g = g' → ∀ {x : B} {f : x ⟶ y}, CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g' | false |
Std.Tactic.BVDecide.BVBinOp.ctorIdx | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp → ℕ | false |
Matroid.Finite.ground_finite | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.Finite], M.E.Finite | true |
SSet.Subcomplex.PairingCore.type₁_dim | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (h : A.PairingCore) (s : h.ι), (h.type₁ s).dim = h.dim s + 1 | true |
Part.map_map | Mathlib.Data.Part | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (g : β → γ) (f : α → β) (o : Part α),
Part.map g (Part.map f o) = Part.map (g ∘ f) o | true |
FractionalIdeal.coeToSubmodule | 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] → FractionalIdeal S P → Submodule R P | true |
_private.Mathlib.Analysis.InnerProductSpace.Subspace.0.«_aux_Mathlib_Analysis_InnerProductSpace_Subspace___macroRules__private_Mathlib_Analysis_InnerProductSpace_Subspace_0_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.Subspace | Lean.Macro | false |
Dense.inter_of_isOpen_left | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, Dense s → Dense t → IsOpen s → Dense (s ∩ t) | true |
_private.Init.Data.Nat.Linear.0.Nat.Linear.Expr.toPoly.go.match_1.eq_2 | Init.Data.Nat.Linear | ∀ (motive : Nat.Linear.Expr → Sort u_1) (i : Nat.Linear.Var) (h_1 : (k : ℕ) → motive (Nat.Linear.Expr.num k))
(h_2 : (i : Nat.Linear.Var) → motive (Nat.Linear.Expr.var i)) (h_3 : (a b : Nat.Linear.Expr) → motive (a.add b))
(h_4 : (k : ℕ) → (a : Nat.Linear.Expr) → motive (Nat.Linear.Expr.mulL k a))
(h_5 : (a : Nat.Linear.Expr) → (k : ℕ) → motive (a.mulR k)),
(match Nat.Linear.Expr.var i with
| Nat.Linear.Expr.num k => h_1 k
| Nat.Linear.Expr.var i => h_2 i
| a.add b => h_3 a b
| Nat.Linear.Expr.mulL k a => h_4 k a
| a.mulR k => h_5 a k) =
h_2 i | true |
AlgebraicGeometry.Scheme.isoSpec_inv_preimage_zeroLocus | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsAffine X] (s : Set ↑(X.presheaf.obj (Opposite.op ⊤))),
⇑X.isoSpec.inv ⁻¹' X.zeroLocus s = PrimeSpectrum.zeroLocus s | true |
Mathlib.Meta.NormNum.isRat_ratCast | Mathlib.Tactic.NormNum.Inv | ∀ {R : Type u_1} [inst : DivisionRing R] [CharZero R] {q : ℚ} {n : ℤ} {d : ℕ},
Mathlib.Meta.NormNum.IsRat q n d → Mathlib.Meta.NormNum.IsRat (↑q) n d | true |
Std.IterM.step_eq | Init.Data.Iterators.Basic | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1}
{IsPlausibleStep : Std.IterM m β → Std.IterStep (Std.IterM m β) β → Prop}
{step : (it : Std.IterM m β) → m (Std.Shrink (Std.PlausibleIterStep (IsPlausibleStep it)))} {it : Std.IterM m β},
it.step = step it | true |
Equiv.commSemigroup | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [CommSemigroup β] → CommSemigroup α | true |
WeierstrassCurve.Jacobian.polynomialZ.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R),
W'.polynomialZ = (MvPolynomial.pderiv 2) W'.polynomial | true |
Submodule.map₂_bot_right | Mathlib.Algebra.Module.Submodule.Bilinear | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : M →ₗ[R] N →ₗ[R] P) (p : Submodule R M), Submodule.map₂ f p ⊥ = ⊥ | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piRightHomBil._proof_2 | Mathlib.LinearAlgebra.TensorProduct.Pi | ∀ (R : Type u_1) [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (N : Type u_4)
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module S N] [inst_6 : IsScalarTower R S N] {ι : Type u_3}
(M : ι → Type u_5) [inst_7 : (i : ι) → AddCommMonoid (M i)] [inst_8 : (i : ι) → Module R (M i)],
SMulCommClass R S ((i : ι) → TensorProduct R N (M i)) | false |
npowRec | Init.Data.Zero | {M : Type u_1} → [One M] → [Mul M] → ℕ → M → M | true |
nhdsWithin_Iio_isMeasurablyGenerated | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [OpensMeasurableSpace α] [inst_2 : LinearOrder α]
{a b : α} [ClosedIciTopology α], (nhdsWithin a (Set.Iio b)).IsMeasurablyGenerated | true |
Lean.Doc.Data.inst._@.Lean.Elab.DocString.Builtin.3430689252._hygCtx._hyg.8 | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.ConvTactic | false |
IsDedekindDomain.HeightOneSpectrum.valuation_of_mk' | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {r : R}
{s : ↥(nonZeroDivisors R)},
(IsDedekindDomain.HeightOneSpectrum.valuation K v) (IsLocalization.mk' K r s) = v.intValuation r / v.intValuation ↑s | true |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.ExcenterExists.excenter_map._simp_1_3 | Mathlib.Geometry.Euclidean.Incenter | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (f : P →ᵃⁱ[𝕜] P₂), ⇑f = ⇑f.toAffineMap | false |
Lean.Core.getAndEmptyMessageLog | Lean.CoreM | Lean.CoreM Lean.MessageLog | true |
SubAddAction.ofStabilizer | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | (G : Type u_1) →
[inst : AddGroup G] →
{α : Type u_2} → [inst_1 : AddAction G α] → (a : α) → SubAddAction (↥(AddAction.stabilizer G a)) α | true |
Std.DTreeMap.Internal.Impl.Const.get_insert! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h : t.WF) {k a : α} {v : β}
{h₁ : Std.DTreeMap.Internal.Impl.contains a (Std.DTreeMap.Internal.Impl.insert! k v t) = true},
Std.DTreeMap.Internal.Impl.Const.get (Std.DTreeMap.Internal.Impl.insert! k v t) a h₁ =
if h₂ : compare k a = Ordering.eq then v else Std.DTreeMap.Internal.Impl.Const.get t a ⋯ | true |
PadicInt.continuous_choose | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℕ), Continuous fun x => Ring.choose x k | true |
HahnSeries.instNontrivialOfNonempty | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [Nonempty Γ] [Nontrivial R],
Nontrivial (HahnSeries Γ R) | true |
ContinuousMap.instNormedRing._proof_4 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NormedRing R]
(a : C(α, R)), 0 * a = 0 | false |
_private.Mathlib.Logic.Equiv.Prod.0.Equiv.prodCongrLeft._proof_3 | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_2} {β₁ : Type u_1} {β₂ : Type u_3} (e : α₁ → β₁ ≃ β₂),
Function.RightInverse (fun ab => ((e ab.2).symm ab.1, ab.2)) fun ab => ((e ab.2) ab.1, ab.2) | false |
SimplexCategory.Truncated.δ₂._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | false |
Fin.pos | Init.Data.Fin.Basic | ∀ {n : ℕ} (i : Fin n), 0 < n | true |
Module.IsReflexive.of_finite_of_free | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.Finite R M] [Module.Free R M], Module.IsReflexive R M | true |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_22 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [IsScalarTower R S T] {P : Algebra.Extension R S}
{Q : Algebra.Extension R T} (f : P.Hom Q) (H : f.toRingHom.FormallyEtale) (x : TensorProduct S T P.CotangentSpace),
(LinearMap.liftBaseChange T
(LinearMap.liftBaseChange Q.Ring
(↑P.Ring ((TensorProduct.mk S T P.CotangentSpace) 1) ∘ₗ
↑P.Ring ((TensorProduct.mk P.Ring S Ω[P.Ring⁄R]) 1)) ∘ₗ
↑(KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale R P.Ring Q.Ring).symm))
((LinearMap.liftBaseChange T (Algebra.Extension.CotangentSpace.map f)).toFun x) =
x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.