tasksource/leandojo huggingface dataset:
Theorem: List.erase_diff_erase_sublist_of_sublist
File: Mathlib/Data/List/Basic.lean

tactic: simp only [heq, erase_cons_head, diff_cons]
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁)

tactic: rfl
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : b = a
⊢ List.diff (List.erase l₂ a) l₁ <+ List.diff (List.erase l₂ a) l₁

tactic: simp only [erase_cons_head b l₁, erase_cons_tail l₁ heq,
  diff_cons ((List.erase l₂ a)) (List.erase l₁ a) b, diff_cons l₂ l₁ b, erase_comm a b l₂]
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ List.diff (List.erase l₂ a) (List.erase (b :: l₁) a) <+ List.diff l₂ (b :: l₁)

tactic: have h' := h.erase b
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
⊢ List.diff (List.erase (List.erase l₂ b) a) (List.erase l₁ a) <+ List.diff (List.erase l₂ b) l₁

tactic: rw [erase_cons_head] at h'
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : List.erase (b :: l₁) b <+ List.erase l₂ b
⊢ List.diff (List.erase (List.erase l₂ b) a) (List.erase l₁ a) <+ List.diff (List.erase l₂ b) l₁

tactic: exact @erase_diff_erase_sublist_of_sublist _ l₁ (l₂.erase b) h'
state_before: ι : Type ?u.428945
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
h : b :: l₁ <+ l₂
heq : ¬b = a
h' : l₁ <+ List.erase l₂ b
⊢ List.diff (List.erase (List.erase l₂ b) a) (List.erase l₁ a) <+ List.diff (List.erase l₂ b) l₁
Theorem: segment_eq_Icc'
File: Mathlib/Analysis/Convex/Segment.lean

tactic: cases' le_total x y with h h
state_before: 𝕜 : Type u_1
E : Type ?u.289591
F : Type ?u.289594
G : Type ?u.289597
ι : Type ?u.289600
π : ι → Type ?u.289605
inst✝ : LinearOrderedField 𝕜
x✝ y✝ z x y : 𝕜
⊢ [x-[𝕜]y] = Icc (min x y) (max x y)

tactic: rw [segment_eq_Icc h, max_eq_right h, min_eq_left h]
state_before: case inl
𝕜 : Type u_1
E : Type ?u.289591
F : Type ?u.289594
G : Type ?u.289597
ι : Type ?u.289600
π : ι → Type ?u.289605
inst✝ : LinearOrderedField 𝕜
x✝ y✝ z x y : 𝕜
h : x ≤ y
⊢ [x-[𝕜]y] = Icc (min x y) (max x y)

tactic: rw [segment_symm, segment_eq_Icc h, max_eq_left h, min_eq_right h]
state_before: case inr
𝕜 : Type u_1
E : Type ?u.289591
F : Type ?u.289594
G : Type ?u.289597
ι : Type ?u.289600
π : ι → Type ?u.289605
inst✝ : LinearOrderedField 𝕜
x✝ y✝ z x y : 𝕜
h : y ≤ x
⊢ [x-[𝕜]y] = Icc (min x y) (max x y)
Theorem: aeSeq.aeSeq_eq_mk_of_mem_aeSeqSet
File: Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean

tactic: simp only [aeSeq, hx, if_true]
state_before: ι : Sort u_3
α : Type u_1
β : Type u_2
γ : Type ?u.207057
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
hf : ∀ (i : ι), AEMeasurable (f i)
x : α
hx : x ∈ aeSeqSet hf p
i : ι
⊢ aeSeq hf p i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x
Theorem: ClosureOperator.ext
File: Mathlib/Order/Closure.lean

tactic: congr
state_before: α : Type u_1
ι : Sort ?u.1113
κ : ι → Sort ?u.1118
inst✝¹ inst✝ : PartialOrder α
c : ClosureOperator α
c₁ : α → α
monotone'✝¹ : Monotone c₁
le_closure'✝¹ : ∀ (x : α), x ≤ ↑{ toFun := c₁, monotone' := monotone'✝¹ } x
idempotent'✝¹ :
  ∀ (x : α),
    ↑{ toFun := c₁, monotone' := monotone'✝¹ } (↑{ toFun := c₁, monotone' := monotone'✝¹ } x) =
      ↑{ toFun := c₁, monotone' := monotone'✝¹ } x
c₂ : α → α
monotone'✝ : Monotone c₂
le_closure'✝ : ∀ (x : α), x ≤ ↑{ toFun := c₂, monotone' := monotone'✝ } x
idempotent'✝ :
  ∀ (x : α),
    ↑{ toFun := c₂, monotone' := monotone'✝ } (↑{ toFun := c₂, monotone' := monotone'✝ } x) =
      ↑{ toFun := c₂, monotone' := monotone'✝ } x
h :
  ↑{ toOrderHom := { toFun := c₁, monotone' := monotone'✝¹ }, le_closure' := le_closure'✝¹,
          idempotent' := idempotent'✝¹ }.toOrderHom =
    ↑{ toOrderHom := { toFun := c₂, monotone' := monotone'✝ }, le_closure' := le_closure'✝,
          idempotent' := idempotent'✝ }.toOrderHom
⊢ { toOrderHom := { toFun := c₁, monotone' := monotone'✝¹ }, le_closure' := le_closure'✝¹,
      idempotent' := idempotent'✝¹ } =
    { toOrderHom := { toFun := c₂, monotone' := monotone'✝ }, le_closure' := le_closure'✝, idempotent' := idempotent'✝ }
Theorem: NonUnitalAlgHom.to_distribMulActionHom_injective
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: ext a
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f g : A →ₙₐ[R] B
h : ↑f = ↑g
⊢ f = g

tactic: exact DistribMulActionHom.congr_fun h a
state_before: case h
R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f g : A →ₙₐ[R] B
h : ↑f = ↑g
a : A
⊢ ↑f a = ↑g a
Theorem: IsLocalizedModule.mk'_cancel_left
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: delta mk'
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.841263
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s₁ s₂ : { x // x ∈ S }
⊢ mk' f (s₁ • m) (s₁ * s₂) = mk' f m s₂

tactic: rw [LocalizedModule.mk_cancel_common_left]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.841263
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s₁ s₂ : { x // x ∈ S }
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk (s₁ • m) (s₁ * s₂)) =
    ↑(fromLocalizedModule S f) (LocalizedModule.mk m s₂)
Theorem: IsPiSystem.pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rintro _ ⟨s₁, hs₁, rfl⟩ _ ⟨s₂, hs₂, rfl⟩ hst
state_before: ι : Type u_2
ι' : Type ?u.16
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
⊢ IsPiSystem (Set.pi univ '' Set.pi univ C)

tactic: rw [← pi_inter_distrib] at hst⊢
state_before: case intro.intro.intro.intro
ι : Type u_2
ι' : Type ?u.16
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ Set.pi univ C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ Set.pi univ C
hst : Set.Nonempty (Set.pi univ s₁ ∩ Set.pi univ s₂)
⊢ Set.pi univ s₁ ∩ Set.pi univ s₂ ∈ Set.pi univ '' Set.pi univ C

tactic: rw [univ_pi_nonempty_iff] at hst
state_before: case intro.intro.intro.intro
ι : Type u_2
ι' : Type ?u.16
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ Set.pi univ C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ Set.pi univ C
hst : Set.Nonempty (Set.pi univ fun i => s₁ i ∩ s₂ i)
⊢ (Set.pi univ fun i => s₁ i ∩ s₂ i) ∈ Set.pi univ '' Set.pi univ C

tactic: exact mem_image_of_mem _ fun i _ => hC i _ (hs₁ i (mem_univ i)) _ (hs₂ i (mem_univ i)) (hst i)
state_before: case intro.intro.intro.intro
ι : Type u_2
ι' : Type ?u.16
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
s₁ : (i : ι) → Set (α i)
hs₁ : s₁ ∈ Set.pi univ C
s₂ : (i : ι) → Set (α i)
hs₂ : s₂ ∈ Set.pi univ C
hst : ∀ (i : ι), Set.Nonempty (s₁ i ∩ s₂ i)
⊢ (Set.pi univ fun i => s₁ i ∩ s₂ i) ∈ Set.pi univ '' Set.pi univ C
Theorem: Matrix.dotProduct_pUnit
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type ?u.123861
m : Type ?u.123864
n : Type ?u.123867
o : Type ?u.123870
m' : o → Type ?u.123875
n' : o → Type ?u.123880
R : Type ?u.123883
S : Type ?u.123886
α : Type v
β : Type w
γ : Type ?u.123893
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
v w : PUnit → α
⊢ v ⬝ᵥ w = v PUnit.unit * w PUnit.unit
Theorem: idRel_subset
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp [subset_def]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.155
s : Set (α × α)
⊢ idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s
Theorem: Rat.cast_nonneg
File: Mathlib/Data/Rat/Cast.lean

tactic: norm_cast
state_before: F : Type ?u.58214
ι : Type ?u.58217
α : Type ?u.58220
β : Type ?u.58223
K : Type u_1
inst✝ : LinearOrderedField K
n : ℚ
⊢ 0 ≤ ↑n ↔ 0 ≤ n
Theorem: Polynomial.IsSeparableContraction.dvd_degree'
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: obtain ⟨m, rfl⟩ := hf.2
state_before: F : Type u_1
inst✝ : CommSemiring F
q : ℕ
f : F[X]
hf✝ : HasSeparableContraction q f
g : F[X]
hf : IsSeparableContraction q f g
⊢ ∃ m, natDegree g * q ^ m = natDegree f

tactic: use m
state_before: case intro
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q (↑(expand F (q ^ m)) g)
hf : IsSeparableContraction q (↑(expand F (q ^ m)) g) g
⊢ ∃ m_1, natDegree g * q ^ m_1 = natDegree (↑(expand F (q ^ m)) g)

tactic: rw [natDegree_expand]
state_before: case intro
F : Type u_1
inst✝ : CommSemiring F
q : ℕ
g : F[X]
m : ℕ
hf✝ : HasSeparableContraction q (↑(expand F (q ^ m)) g)
hf : IsSeparableContraction q (↑(expand F (q ^ m)) g) g
⊢ natDegree g * q ^ m = natDegree (↑(expand F (q ^ m)) g)
Theorem: PiNat.mem_cylinder_iff_eq
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: constructor
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n ↔ cylinder y n = cylinder x n

tactic: intro hy
state_before: case mp
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n → cylinder y n = cylinder x n

tactic: apply Subset.antisymm
state_before: case mp
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
⊢ cylinder y n = cylinder x n

tactic: intro z hz i hi
state_before: case mp.h₁
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
⊢ cylinder y n ⊆ cylinder x n

tactic: rw [← hy i hi]
state_before: case mp.h₁
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder y n
i : ℕ
hi : i < n
⊢ z i = x i

tactic: exact hz i hi
state_before: case mp.h₁
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder y n
i : ℕ
hi : i < n
⊢ z i = y i

tactic: intro z hz i hi
state_before: case mp.h₂
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
⊢ cylinder x n ⊆ cylinder y n

tactic: rw [hy i hi]
state_before: case mp.h₂
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder x n
i : ℕ
hi : i < n
⊢ z i = y i

tactic: exact hz i hi
state_before: case mp.h₂
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
hy : y ∈ cylinder x n
z : (n : ℕ) → E n
hz : z ∈ cylinder x n
i : ℕ
hi : i < n
⊢ z i = x i

tactic: intro h
state_before: case mpr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ cylinder y n = cylinder x n → y ∈ cylinder x n

tactic: rw [← h]
state_before: case mpr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : cylinder y n = cylinder x n
⊢ y ∈ cylinder x n

tactic: exact self_mem_cylinder _ _
state_before: case mpr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
h : cylinder y n = cylinder x n
⊢ y ∈ cylinder y n
Theorem: CategoryTheory.IsIso.inv_eq_of_hom_inv_id
File: Mathlib/CategoryTheory/Iso.lean

tactic: apply (cancel_epi f).mp
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : IsIso f
g : Y ⟶ X
hom_inv_id : f ≫ g = 𝟙 X
⊢ inv f = g

tactic: simp [hom_inv_id]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : IsIso f
g : Y ⟶ X
hom_inv_id : f ≫ g = 𝟙 X
⊢ f ≫ inv f = f ≫ g
Theorem: Polynomial.ne_zero_of_ne_zero_of_monic
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rintro rfl
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hq : Monic q
⊢ q ≠ 0

tactic: rw [Monic.def, leadingCoeff_zero] at hq
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r : R[X]
hp : p ≠ 0
hq : Monic 0
⊢ False

tactic: rw [← mul_one p, ← C_1, ← hq, C_0, mul_zero] at hp
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r : R[X]
hp : p ≠ 0
hq : 0 = 1
⊢ False

tactic: exact hp rfl
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r : R[X]
hp : 0 ≠ 0
hq : 0 = 1
⊢ False
Theorem: Ideal.IsDedekindDomain.ramificationIdx_eq_factors_count
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: rw [IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count hp0 hP hP0,
  factors_eq_normalizedFactors]
state_before: R : Type u
inst✝³ : CommRing R
S : Type v
inst✝² : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝¹ : IsDomain S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : IsPrime P
hP0 : P ≠ ⊥
⊢ ramificationIdx f p P = Multiset.count P (factors (map f p))
Theorem: Ideal.finset_inf_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: ext x
state_before: R : Type u
ι✝ : Type ?u.253392
inst✝ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_1
s : Finset ι
I : ι → R
hI : Set.Pairwise (↑s) (IsCoprime on I)
⊢ (Finset.inf s fun i => span {I i}) = span {∏ i in s, I i}

tactic: simp only [Submodule.mem_finset_inf, Ideal.mem_span_singleton]
state_before: case h
R : Type u
ι✝ : Type ?u.253392
inst✝ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_1
s : Finset ι
I : ι → R
hI : Set.Pairwise (↑s) (IsCoprime on I)
x : R
⊢ (x ∈ Finset.inf s fun i => span {I i}) ↔ x ∈ span {∏ i in s, I i}

tactic: exact ⟨Finset.prod_dvd_of_coprime hI, fun h i hi => (Finset.dvd_prod_of_mem _ hi).trans h⟩
state_before: case h
R : Type u
ι✝ : Type ?u.253392
inst✝ : CommSemiring R
I✝ J K L : Ideal R
ι : Type u_1
s : Finset ι
I : ι → R
hI : Set.Pairwise (↑s) (IsCoprime on I)
x : R
⊢ (∀ (i : ι), i ∈ s → I i ∣ x) ↔ ∏ i in s, I i ∣ x
Theorem: MvPolynomial.cardinal_mk_eq_max
File: Mathlib/Data/MvPolynomial/Cardinal.lean

tactic: simp
state_before: σ R : Type u
inst✝² : CommSemiring R
inst✝¹ : Nonempty σ
inst✝ : Nontrivial R
⊢ (#MvPolynomial σ R) = max (max (#R) (#σ)) ℵ₀
Theorem: mul_lt_iff_lt_one_right'
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [one_mul]
state_before: α : Type u_1
β : Type ?u.26724
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < b ↔ a * b < 1 * b
Theorem: Ultrafilter.le_of_inf_neBot'
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rwa [inf_comm]
state_before: α : Type u
β : Type v
γ : Type ?u.5713
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
f : Ultrafilter α
g : Filter α
hg : NeBot (g ⊓ ↑f)
⊢ NeBot (↑f ⊓ g)
Theorem: LieSubmodule.ucs_comap_incl
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
⊢ comap (incl N) (ucs k ⊥) = ucs k ⊥

tactic: exact N.ker_incl
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
⊢ comap (incl N) (ucs Nat.zero ⊥) = ucs Nat.zero ⊥

tactic: simp [← ih]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
ih : comap (incl N) (ucs k ⊥) = ucs k ⊥
⊢ comap (incl N) (ucs (Nat.succ k) ⊥) = ucs (Nat.succ k) ⊥
Theorem: Filter.mem_coprodᵢ_iff
File: Mathlib/Order/Filter/Pi.lean

tactic: simp [Filter.coprodᵢ]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
s : Set ((i : ι) → α i)
⊢ s ∈ Filter.coprodᵢ f ↔ ∀ (i : ι), ∃ t₁, t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
Theorem: Set.Ioo_union_Ioi
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total a b with hab hab <;> simp [hab] at h
state_before: α : Type u_1
β : Type ?u.78994
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h : c < max a b
⊢ Ioo a b ∪ Ioi c = Ioi (min a c)

tactic: exact Ioo_union_Ioi' h
state_before: case inl
α : Type u_1
β : Type ?u.78994
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
h : c < b
⊢ Ioo a b ∪ Ioi c = Ioi (min a c)

tactic: rw [min_comm]
state_before: case inr
α : Type u_1
β : Type ?u.78994
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
h : c < a
⊢ Ioo a b ∪ Ioi c = Ioi (min a c)

tactic: simp [*, min_eq_left_of_lt]
state_before: case inr
α : Type u_1
β : Type ?u.78994
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
h : c < a
⊢ Ioo a b ∪ Ioi c = Ioi (min c a)
Theorem: Matrix.mem_orthogonalGroup_iff'
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

tactic: refine' ⟨And.left, fun hA => ⟨hA, _⟩⟩
state_before: n : Type u
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
α : Type v
inst✝² : CommRing α
inst✝¹ : StarRing α
A✝ : Matrix n n α
β : Type v
inst✝ : CommRing β
A : Matrix n n β
⊢ A ∈ orthogonalGroup n β ↔ star A * A = 1

tactic: rwa [mul_eq_mul, mul_eq_one_comm] at hA
state_before: n : Type u
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
α : Type v
inst✝² : CommRing α
inst✝¹ : StarRing α
A✝ : Matrix n n α
β : Type v
inst✝ : CommRing β
A : Matrix n n β
hA : star A * A = 1
⊢ A * star A = 1
Theorem: sign_nonneg_iff
File: Mathlib/Data/Sign.lean

tactic: rcases lt_trichotomy 0 a with (h | h | h)
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
⊢ 0 ≤ ↑sign a ↔ 0 ≤ a

tactic: simp [h, h.le]
state_before: case inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 < a
⊢ 0 ≤ ↑sign a ↔ 0 ≤ a

tactic: simp [←h]
state_before: case inr.inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 = a
⊢ 0 ≤ ↑sign a ↔ 0 ≤ a

tactic: simp [h, h.not_le]
state_before: case inr.inr
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : a < 0
⊢ 0 ≤ ↑sign a ↔ 0 ≤ a
Theorem: pow_bit0_pos_iff
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: refine' ⟨fun h => _, fun h => pow_bit0_pos h n⟩
state_before: β : Type ?u.253925
A : Type ?u.253928
G : Type ?u.253931
M : Type ?u.253934
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hn : n ≠ 0
⊢ 0 < a ^ bit0 n ↔ a ≠ 0

tactic: rintro rfl
state_before: β : Type ?u.253925
A : Type ?u.253928
G : Type ?u.253931
M : Type ?u.253934
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hn : n ≠ 0
h : 0 < a ^ bit0 n
⊢ a ≠ 0

tactic: rw [zero_pow (Nat.zero_lt_bit0 hn)] at h
state_before: β : Type ?u.253925
A : Type ?u.253928
G : Type ?u.253931
M : Type ?u.253934
R : Type u_1
inst✝ : LinearOrderedRing R
n : ℕ
hn : n ≠ 0
h : 0 < 0 ^ bit0 n
⊢ False

tactic: exact lt_irrefl _ h
state_before: β : Type ?u.253925
A : Type ?u.253928
G : Type ?u.253931
M : Type ?u.253934
R : Type u_1
inst✝ : LinearOrderedRing R
n : ℕ
hn : n ≠ 0
h : 0 < 0
⊢ False
Theorem: tendsto_exp_mul_div_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: refine' ((tendsto_rpow_atTop hb).comp (tendsto_exp_div_rpow_atTop (s / b))).congr' _
state_before: s b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => exp (b * x) / x ^ s) atTop atTop

tactic: filter_upwards [eventually_ge_atTop (0 : ℝ)]with x hx₀
state_before: s b : ℝ
hb : 0 < b
⊢ ((fun x => x ^ b) ∘ fun x => exp x / x ^ (s / b)) =ᶠ[atTop] fun x => exp (b * x) / x ^ s

tactic: simp [Real.div_rpow, (exp_pos x).le, rpow_nonneg_of_nonneg, ← Real.rpow_mul, ← exp_mul,
  mul_comm x, hb.ne', *]
state_before: case h
s b : ℝ
hb : 0 < b
x : ℝ
hx₀ : 0 ≤ x
⊢ ((fun x => x ^ b) ∘ fun x => exp x / x ^ (s / b)) x = exp (b * x) / x ^ s
Theorem: ContinuousMap.continuous_restrict
File: Mathlib/Topology/CompactOpen.lean

tactic: rw [continuous_iff_le_induced]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23355
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
s : Set α
⊢ Continuous fun F => restrict s F

tactic: exact compactOpen_le_induced s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.23355
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
s : Set α
⊢ compactOpen ≤ TopologicalSpace.induced (fun F => restrict s F) compactOpen
Theorem: List.rotate_eq_drop_append_take_mod
File: Mathlib/Data/List/Rotate.lean

tactic: cases' l.length.zero_le.eq_or_lt with hl hl
state_before: α : Type u
l : List α
n : ℕ
⊢ rotate l n = drop (n % length l) l ++ take (n % length l) l

tactic: rw [← rotate_eq_drop_append_take (n.mod_lt hl).le, rotate_mod]
state_before: case inr
α : Type u
l : List α
n : ℕ
hl : 0 < length l
⊢ rotate l n = drop (n % length l) l ++ take (n % length l) l

tactic: simp [eq_nil_of_length_eq_zero hl.symm]
state_before: case inl
α : Type u
l : List α
n : ℕ
hl : 0 = length l
⊢ rotate l n = drop (n % length l) l ++ take (n % length l) l
Theorem: Module.End.maximalGeneralizedEigenspace_eq
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [isNoetherian_iff_wellFounded] at h
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian R M
f : End R M
μ : R
⊢ maximalGeneralizedEigenspace f μ = ↑(generalizedEigenspace f μ) (maximalGeneralizedEigenspaceIndex f μ)

tactic: exact (WellFounded.iSup_eq_monotonicSequenceLimit h (f.generalizedEigenspace μ) : _)
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : WellFounded fun x x_1 => x > x_1
f : End R M
μ : R
⊢ maximalGeneralizedEigenspace f μ = ↑(generalizedEigenspace f μ) (maximalGeneralizedEigenspaceIndex f μ)
Theorem: CategoryTheory.Arrow.mk_injective
File: Mathlib/CategoryTheory/Arrow.lean

tactic: cases h
state_before: T : Type u
inst✝ : Category T
A B : T
f g : A ⟶ B
h : mk f = mk g
⊢ f = g

tactic: rfl
state_before: case refl
T : Type u
inst✝ : Category T
A B : T
f : A ⟶ B
⊢ f = f
Theorem: Int.clog_zpow
File: Mathlib/Data/Int/Log.lean

tactic: rw [← neg_log_inv_eq_clog, ← zpow_neg, log_zpow hb, neg_neg]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : 1 < b
z : ℤ
⊢ clog b (↑b ^ z) = z