name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.LinearAlgebra.AffineSpace.Independent.0.AffineIndependent.affineIndependent_of_notMem_span._simp_1_3 | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a + -b = 0) = (a = b) | false |
HomotopicalAlgebra.PathObject.ctorIdx | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C} → {A : C} → HomotopicalAlgebra.PathObject A → ℕ | false |
GradedAlgHom.mk.noConfusion | Mathlib.RingTheory.GradedAlgebra.AlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{ι : Type u_4} →
{inst : CommSemiring R} →
{inst_1 : Semiring A} →
{inst_2 : Semiring B} →
{inst_3 : Algebra R A} →
{inst_4 : Algebra R B} →
{inst_5 : DecidableEq ι} →
... | false |
map_derivedSeries_eq | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {f : G →* G'},
Function.Surjective ⇑f → ∀ (n : ℕ), Subgroup.map f (derivedSeries G n) = derivedSeries G' n | true |
CategoryTheory.Functor.pointwiseRightKanExtensionCompIsoOfPreserves_inv_fac | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | true |
Lean.PersistentEnvExtensionDescrCore.name | Lean.Environment | {α β σ : Type} → Lean.PersistentEnvExtensionDescrCore α β σ → Lean.Name | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.zero_lt_iff._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Aesop.RuleTacDescr.tacGen.elim | Aesop.RuleTac.Descr | {motive : Aesop.RuleTacDescr → Sort u} →
(t : Aesop.RuleTacDescr) → t.ctorIdx = 6 → ((decl : Lean.Name) → motive (Aesop.RuleTacDescr.tacGen decl)) → motive t | false |
Ideal.Quotient.ring._proof_8 | Mathlib.RingTheory.Ideal.Quotient.Defs | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] (a : R ⧸ I), 1 * a = a | false |
LieHom.inverse._proof_2 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
instIsScalarTowerAtPrimeFractionRing_1 | Mathlib.RingTheory.DedekindDomain.Instances | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {P : Ideal R} [inst_2 : P.IsPrime],
IsScalarTower R (Localization.AtPrime P) (FractionRing R) | true |
Finset.instHasSubset.hcongr_1 | Mathlib.Order.SupIndep | ∀ (α α' : Type u_1), α = α' → Finset.instHasSubset ≍ Finset.instHasSubset | true |
Encodable.iSup_decode₂ | Mathlib.Logic.Encodable.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable β] [inst_1 : CompleteLattice α] (f : β → α),
⨆ i, ⨆ b ∈ Encodable.decode₂ β i, f b = ⨆ b, f b | true |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.TaggedState.out._default | Lean.Widget.TaggedText | Lean.Widget.TaggedText (ℕ × ℕ) | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.cyclesMap'_eq | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
(γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂), CategoryTheory.ShortComplex.cy... | true |
NonUnitalAlgHom.fst_apply | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ (R : Type u) [inst : Monoid R] (A : Type v) (B : Type w) [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : DistribMulAction R B] (self : A × B),
(NonUnitalAlgHom.fst R A B) self = self.1 | true |
Stream'.Seq.destruct_eq_none | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {s : Stream'.Seq α}, s.destruct = none → s = Stream'.Seq.nil | true |
WithVal.linearEquiv | Mathlib.Topology.Algebra.Valued.WithVal | (R : Type u_1) →
{Γ₀ : Type u_2} →
[inst : LinearOrderedCommGroupWithZero Γ₀] →
[inst_1 : Ring R] →
{S : Type u_3} → [inst_2 : Ring S] → [inst_3 : Module R S] → (v : Valuation S Γ₀) → WithVal v ≃ₗ[R] S | true |
eq_of_mabs_div_lt_all | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {x y : G},
(∀ ε > 1, |x / y|ₘ < ε) → x = y | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.getPatternArgKinds._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.BinderInfo → Sort u} →
(t : Lean.BinderInfo) → motive Lean.BinderInfo.instImplicit → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.Array.Lemmas.0.Array.mem_replicate._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ List.replicate n a) = (n ≠ 0 ∧ b = a) | false |
_private.Mathlib.RingTheory.Localization.FractionRing.0.IsFractionRing.nonZeroDivisors_eq_isUnit.match_1_1 | Mathlib.RingTheory.Localization.FractionRing | ∀ (R : Type u_1) [inst : CommRing R] (K : Type u_2) [inst_1 : CommRing K] [inst_2 : Algebra R K] (x : K)
(motive : (∃ x_1, x * (algebraMap R K) ↑x_1.2 = (algebraMap R K) x_1.1) → Prop)
(x_1 : ∃ x_1, x * (algebraMap R K) ↑x_1.2 = (algebraMap R K) x_1.1),
(∀ (r : R × ↥(nonZeroDivisors R)) (eq : x * (algebraMap R K)... | false |
CategoryTheory.ComposableArrows.mapFunctorArrows._proof_18 | Mathlib.CategoryTheory.ComposableArrows.One | ∀ (j' n : ℕ), autoParam (j' ≤ n) CategoryTheory.ComposableArrows.mapFunctorArrows._auto_9 → j' ≤ n | false |
AddSubmonoid.sup_eq_range | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {N : Type u_4} [inst : AddCommMonoid N] (s t : AddSubmonoid N),
s ⊔ t = AddMonoidHom.mrange (s.subtype.coprod t.subtype) | true |
WithTop.decidableLT.match_1 | Mathlib.Order.WithBot | {α : Type u_1} →
(motive : WithTop α → WithTop α → Sort u_2) →
(x x_1 : WithTop α) →
((x : WithTop α) → motive x none) →
((a : α) → motive none (some a)) → ((a b : α) → motive (some a) (some b)) → motive x x_1 | false |
UniformFun.hasBasis_nhds_zero | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G],
(nhds 0).HasBasis (fun V => V ∈ nhds 0) fun V => {f | ∀ (x : α), f x ∈ V} | true |
Delone.DeloneSet | Mathlib.Analysis.AperiodicOrder.Delone.Basic | (X : Type u_3) → [MetricSpace X] → Type u_3 | true |
_private.Mathlib.Data.List.Flatten.0.List.getLast_getLast_eq_getLast_flatten._proof_1_16 | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {l : List (List α)} (hl : l ≠ []),
l.getLast hl ≠ [] →
∀ (w : List (List α)) (w_1 : List α), l = w.concat w_1 → [w_1].flatten.isEmpty = true → w.flatten ≠ [] | false |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.Slice.startPos_eq_endPos_iff._simp_1_3 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String.Slice}, (s.isEmpty = true) = (s.utf8ByteSize = 0) | false |
Orientation.oangle_zero_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V), o.oangle x 0 = 0 | true |
CategoryTheory.Limits.FormalCoproduct.evalOp._proof_2 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_5, u_2} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
(F : CategoryTheory.Functor Cᵒᵖ A) (X : (CategoryTheory.Limits.FormalCoproduct C)ᵒᵖ),
(CategoryTheory.Limits.Pi.lift fun i =>
CategoryT... | false |
Aesop.EMap.findWithKey? | Aesop.EMap | {α : Type} → Lean.Expr → Aesop.EMap α → Lean.MetaM (Option (Lean.Expr × α)) | true |
_private.Mathlib.Topology.MetricSpace.HolderNorm.0.HolderOnWith.exists_holderOnWith_of_le'._simp_1_1 | Mathlib.Topology.MetricSpace.HolderNorm | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal} {f : X → Y}
{s : Set X}, HolderOnWith C r f s = HolderWith C r (s.restrict f) | false |
_private.Mathlib.Data.Prod.Basic.0.Prod.Lex.refl_left.match_1_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (x : α × β),
(∀ (fst : α) (snd : β), motive (fst, snd)) → motive x | false |
intervalIntegral.integral_nonneg_of_ae_restrict | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b → 0 ≤ᵐ[μ.restrict (Set.Icc a b)] f → 0 ≤ ∫ (u : ℝ) in a..b, f u ∂μ | true |
Nat.pow_length_le_mul_ofDigits | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b : ℕ} {l : List ℕ} (hl : l ≠ []), l.getLast hl ≠ 0 → (b + 2) ^ l.length ≤ (b + 2) * Nat.ofDigits (b + 2) l | true |
UInt16.ofNat_bitVecToNat | Init.Data.UInt.Lemmas | ∀ (n : BitVec 16), UInt16.ofNat n.toNat = { toBitVec := n } | true |
ContinuousMultilinearMap.piₗᵢ._proof_5 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {ι' : Type u_2} {E' : ι' → Type u_3}
[inst_1 : (i' : ι') → NormedAddCommGroup (E' i')] [inst_2 : (i' : ι') → NormedSpace 𝕜 (E' i')],
ContinuousConstSMul 𝕜 ((i : ι') → E' i) | false |
RingCat.FilteredColimits.colimitRing._proof_3 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J RingCat)
(a b : ↑(AddCommGrpCat.FilteredColimits.G (F.comp (CategoryTheory.forget₂ RingCat AddCommGrpCat)))), a - b = a + -b | false |
RatFunc.Luroth.transcendental_generator | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)},
E ≠ ⊥ → Transcendental K (RatFunc.Luroth.generator E) | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal.termL' | Mathlib.CategoryTheory.Localization.Monoidal.Basic | Lean.ParserDescr | true |
Lean.TraceElem.mk._flat_ctor | Lean.Util.Trace | Lean.Syntax → Lean.MessageData → Lean.TraceElem | false |
Real.iter_deriv_exp | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ (n : ℕ), deriv^[n] Real.exp = Real.exp | true |
conjneg_nonpos | Mathlib.Algebra.Order.Star.Conjneg | ∀ {G : Type u_1} {R : Type u_2} [inst : AddGroup G] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[inst_3 : StarRing R] [StarOrderedRing R] {f : G → R}, conjneg f ≤ 0 ↔ f ≤ 0 | true |
RingEquiv.toMonoidHom_commutes | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R ≃+* S),
↑↑f = (↑f).toMonoidHom | true |
_private.Init.Grind.ToInt.0.Lean.Grind.IntInterval.wrap_mul.match_1_1 | Init.Grind.ToInt | ∀ (motive : (i : Lean.Grind.IntInterval) → i.isFinite = true → Prop) (i : Lean.Grind.IntInterval)
(h : i.isFinite = true),
(∀ (lo hi : ℤ) (h : (Lean.Grind.IntInterval.co lo hi).isFinite = true), motive (Lean.Grind.IntInterval.co lo hi) h) →
motive i h | false |
CategoryTheory.NatTrans._sizeOf_1 | Mathlib.CategoryTheory.NatTrans | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F G : CategoryTheory.Functor C D} → [SizeOf C] → [SizeOf D] → CategoryTheory.NatTrans F G → ℕ | false |
nsmulRec.eq_2 | Mathlib.Algebra.Group.Defs | ∀ {M : Type u_1} [inst : Zero M] [inst_1 : Add M] (x : M) (n : ℕ), nsmulRec n.succ x = nsmulRec n x + x | true |
_private.Mathlib.Data.Nat.Bits.0.Nat.shiftLeft'_add.match_1_1 | Mathlib.Data.Nat.Bits | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.specializeApp?.match_14 | Lean.Compiler.LCNF.Specialize | (motive : Option ((pu : Lean.Compiler.LCNF.Purity) × Lean.Compiler.LCNF.Decl pu) → Sort u_1) →
(__x : Option ((pu : Lean.Compiler.LCNF.Purity) × Lean.Compiler.LCNF.Decl pu)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
motive (some ⟨Lean.Compiler.LCNF.Purity.pure, decl⟩)) →
(... | false |
Lean.Widget.RpcEncodablePacket._sizeOf_inst._@.Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | SizeOf Lean.Widget.RpcEncodablePacket✝ | false |
ENat.recTopCoe_top | Mathlib.Data.ENat.Defs | ∀ {C : ℕ∞ → Sort u_1} (d : C ⊤) (f : (a : ℕ) → C ↑a), ENat.recTopCoe d f ⊤ = d | true |
NumberField.RingOfIntegers.eq_iff | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x y : NumberField.RingOfIntegers K}, ↑x = ↑y ↔ x = y | true |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.notMem_range_embeddingUpIntLE_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p n : ℤ), ¬p < n → p - ↑(p - n).natAbs = n | false |
RingCat.Colimits.Relation.below.trans | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J RingCat}
{motive : (a a_1 : RingCat.Colimits.Prequotient F) → RingCat.Colimits.Relation F a a_1 → Prop}
(x y z : RingCat.Colimits.Prequotient F) (x_1 : RingCat.Colimits.Relation F x y)
(x_2 : RingCat.Colimits.Relation F y z),
R... | true |
PreAbstractSimplicialComplex.instCompleteLattice | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → CompleteLattice (PreAbstractSimplicialComplex ι) | true |
AlgebraicGeometry.instCreatesColimitOverSchemeTopMorphismPropertyOverForget._proof_1 | Mathlib.AlgebraicGeometry.LimitsOver | ⊤.IsMultiplicative | false |
_private.Mathlib.Analysis.SpecialFunctions.Log.Summable.0.Real.multipliable_of_summable_log'._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.Summable | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → (a = b) = False | false |
Std.Sat.AIG.Entrypoint.mk.injEq | Std.Sat.AIG.Basic | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] (aig : Std.Sat.AIG α) (ref : aig.Ref) (aig_1 : Std.Sat.AIG α)
(ref_1 : aig_1.Ref), ({ aig := aig, ref := ref } = { aig := aig_1, ref := ref_1 }) = (aig = aig_1 ∧ ref ≍ ref_1) | true |
WittVector.frobeniusPoly.eq_1 | Mathlib.RingTheory.WittVector.Frobenius | ∀ (p n : ℕ), WittVector.frobeniusPoly p n = MvPolynomial.X n ^ p + MvPolynomial.C ↑p * WittVector.frobeniusPolyAux p n | true |
OrderDual.instAddMonoidWithOne | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [h : AddMonoidWithOne R] → AddMonoidWithOne Rᵒᵈ | true |
CategoryTheory.Coverage.Saturate.below | Mathlib.CategoryTheory.Sites.Coverage | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{K : CategoryTheory.Coverage C} →
{motive : (X : C) → (a : CategoryTheory.Sieve X) → K.Saturate X a → Prop} →
{X : C} → {a : CategoryTheory.Sieve X} → K.Saturate X a → Prop | true |
CategoryTheory.Functor.whiskeringLeft₃_obj_obj_obj_obj_obj_map_app | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheo... | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.mem_insert.match_1_10 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v : α} {t : Batteries.RBNode α} (v_1 : α)
(motive : (∃ L R, t.toList = L ++ v_1 :: R ∧ (Batteries.RBNode.insert cmp t v).toList = L ++ v :: R) → Prop)
(x : ∃ L R, t.toList = L ++ v_1 :: R ∧ (Batteries.RBNode.insert cmp t v).toList = L ++ v :: R),
(∀ (w w_1 : List α) (h₁ ... | false |
_private.Mathlib.Algebra.Group.Pointwise.Set.ListOfFn.0.Set.mem_list_prod._simp_1_3 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u} {m n : ℕ} {f : Fin m → α} {g : Fin n → α}, (List.ofFn f = List.ofFn g) = (⟨m, f⟩ = ⟨n, g⟩) | false |
Ideal.quotientRangePowQuotSuccInclusionEquiv | Mathlib.NumberTheory.RamificationInertia.Basic | {R : Type u} →
[inst : CommRing R] →
{S : Type v} →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
(P : Ideal S) →
[hfp : NeZero (p.ramificationIdx P)] →
[IsDedekindDomain S] →
[P.IsPrime] →
P... | true |
Nat.AtLeastTwo.toNeZero | Mathlib.Data.Nat.Init | ∀ (n : ℕ) [n.AtLeastTwo], NeZero n | true |
_private.Lean.Util.CollectMVars.0.Lean.CollectMVars.main.match_1 | Lean.Util.CollectMVars | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((b... | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.single._proof_8 | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (j k : J)
(hk : CategoryTheory.ObjectProperty.ofObj (fun x => j) k), (fun x => ⟨j, ⋯⟩) PUnit.unit = ⟨k, hk⟩ | false |
SimpleGraph.Walk.mem_support_iff_exists_mem_edges | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v}, w ∈ p.support ↔ w = v ∨ ∃ e ∈ p.edges, w ∈ e | true |
List.head_eq_getLast_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (h : l ≠ []), l.head h = l.reverse.getLast ⋯ | true |
LinearIsometry.toAffineIsometry._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_3} {V : Type u_2} {V₂ : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : SeminormedAddCommGroup V₂] [inst_4 : NormedSpace 𝕜 V₂] (f : V →ₗᵢ[𝕜] V₂) (x : V),
‖f x‖ = ‖x‖ | false |
Finset.sup_div_left | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : Div α] [inst_2 : SemilatticeSup β]
[inst_3 : OrderBot β] (s t : Finset α) (f : α → β), (s / t).sup f = s.sup fun x => t.sup fun x_1 => f (x / x_1) | true |
unitary.map_comp | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (g : S →⋆* T) (f : R →⋆* S),
Unitary.map (g.comp f) = (Unitary.map g).comp (Unitary.map f) | true |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.isClosed_coe_fd.match_1_3 | Mathlib.NumberTheory.Modular | ∀ (x : ℂ) (motive : x ∈ {z | 0 ≤ z.im ∧ 1 ≤ ‖z‖ ∧ |z.re| ≤ 1 / 2} → Prop)
(x_1 : x ∈ {z | 0 ≤ z.im ∧ 1 ≤ ‖z‖ ∧ |z.re| ≤ 1 / 2}),
(∀ (him : 0 ≤ x.im) (hre : 1 ≤ ‖x‖) (hnorm : |x.re| ≤ 1 / 2), motive ⋯) → motive x_1 | false |
EReal.toReal_pos | Mathlib.Data.EReal.Basic | ∀ {x : EReal}, 0 < x → x ≠ ⊤ → 0 < x.toReal | true |
Int.tdiv_self | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ}, a ≠ 0 → a.tdiv a = 1 | true |
CategoryTheory.Arrow.squareToSnd_left | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {i : CategoryTheory.Arrow C} {f : X ⟶ Y}
{g : Y ⟶ Z} (sq : i ⟶ CategoryTheory.Arrow.mk (CategoryTheory.CategoryStruct.comp f g)),
(CategoryTheory.Arrow.squareToSnd sq).left = CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.left sq) f | true |
Std.ExtDHashMap.Const.getD_erase | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {fallback : β},
Std.ExtDHashMap.Const.getD (m.erase k) a fallback =
if (k == a) = true then fallback else Std.ExtDHashMap.Const.getD m a fallback | true |
Subgroup.pi_mem_of_mulSingle_mem_aux | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] (I : Finset η)
{H : Subgroup ((i : η) → f i)} (x : (i : η) → f i), (∀ i ∉ I, x i = 1) → (∀ i ∈ I, Pi.mulSingle i (x i) ∈ H) → x ∈ H | true |
nhds_translation_div | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] (x : G),
Filter.comap (fun x_1 => x_1 / x) (nhds 1) = nhds x | true |
Complex.ofReal_cos_ofReal_re | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), ↑(Complex.cos ↑x).re = Complex.cos ↑x | true |
Bundle.Trivialization.mk_coordChange | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e₁ e₂ : Bundle.Trivialization F proj) {b : B},
b ∈ e₁.baseSet → b ∈ e₂.baseSet → ∀ (x : F), (b, e₁.coordChange e₂ b x) = ↑e₂ (↑e₁.symm (b, x)) | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.instIteratorId.match_3.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice} (motive : Std.IterM Id String.Slice → Sort u_1) (currPos : s.Pos)
(searcher : Std.Iter (String.Slice.Pattern.SearchStep s))
(h_1 :
(currPos : s.Pos) →
(searcher : Std.Iter (String.Sl... | true |
_private.Init.Meta.Defs.0.Lean.expandMacros.match_1 | Init.Meta.Defs | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((stx : Lean.Syntax) → motive stx) → motive stx | false |
Nat.Even.sub_odd | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → Even m → Odd n → Odd (m - n) | true |
_private.Lean.Meta.Eqns.0.Lean.Meta.registerEqnThms | Lean.Meta.Eqns | Lean.Name → Array Lean.Name → Lean.CoreM Unit | true |
Lean.Grind.Linarith.instBEqExpr.beq._f | Init.Grind.Ordered.Linarith | (x : Lean.Grind.Linarith.Expr) →
Lean.Grind.Linarith.Expr.below (motive := fun x => Lean.Grind.Linarith.Expr → Bool) x →
Lean.Grind.Linarith.Expr → Bool | false |
_private.Mathlib.NumberTheory.Multiplicity.0.Int.two_pow_sub_pow._simp_1_4 | Mathlib.NumberTheory.Multiplicity | (¬False) = True | false |
CategoryTheory.WithTerminal.instFullIncl | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.WithTerminal.incl.Full | true |
DihedralGroup.instGroup._proof_15 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (a : DihedralGroup n), DihedralGroup.inv✝ a * a = 1 | false |
instFintypeSym'OfDecidableEq._proof_3 | Mathlib.Data.Fintype.Vector | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {n : ℕ} (x : Sym.Sym' α n),
x ∈ instFintypeSym'OfDecidableEq._aux_1 | false |
IsAddCommutative.rec | Mathlib.Algebra.Group.Defs | {M : Type u_2} →
[inst : Add M] →
{motive : IsAddCommutative M → Sort u} →
((is_comm : Std.Commutative fun x1 x2 => x1 + x2) → motive ⋯) → (t : IsAddCommutative M) → motive t | false |
SimplexCategory.revEquivalence_unitIso | Mathlib.AlgebraicTopology.SimplexCategory.Rev | SimplexCategory.revEquivalence.unitIso = SimplexCategory.revCompRevIso.symm | true |
NonAssocRing.toNatCast | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → [self : NonAssocRing α] → NatCast α | true |
Lean.unreachIsNodeIdent | Lean.Syntax | {β : Sort u_1} →
{info : Lean.SourceInfo} →
{rawVal : Substring.Raw} →
{val : Lean.Name} →
{preresolved : List Lean.Syntax.Preresolved} → Lean.IsNode (Lean.Syntax.ident info rawVal val preresolved) → β | true |
CategoryTheory.Equivalence.mapAction_functor | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_2} {W : Type u_3} [inst : CategoryTheory.Category.{v_2, u_2} V]
[inst_1 : CategoryTheory.Category.{v_3, u_3} W] (G : Type u_4) [inst_2 : Monoid G] (E : V ≌ W),
(CategoryTheory.Equivalence.mapAction G E).functor = E.functor.mapAction G | true |
Cardinal.lt_power_cof_ord | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c < c ^ c.ord.cof | true |
Encodable.length_le_encode._f | Mathlib.Logic.Equiv.List | ∀ {α : Type u_1} [inst : Encodable α] (x : List α) (f : List.below x), x.length ≤ Encodable.encode x | false |
CategoryTheory.Endofunctor.instInhabitedCoalgebraId | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[Inhabited C] → Inhabited (CategoryTheory.Endofunctor.Coalgebra (CategoryTheory.Functor.id C)) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.