1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.contDiffOn_convolution_left_with_param
File: Mathlib/Analysis/Convolution.lean

tactic: simpa only [convolution_flip] using contDiffOn_convolution_right_with_param L.flip hs hk hgs hf hg
state_before: 𝕜 : Type u𝕜
G : Type uG
E : Type uE
E' : Type uE'
E'' : Type uE''
F : Type uF
F' : Type uF'
F'' : Type uF''
P : Type uP
inst✝¹⁸ : NormedAddCommGroup E
inst✝¹⁷ : NormedAddCommGroup E'
inst✝¹⁶ : NormedAddCommGroup E''
inst✝¹⁵ : NormedAddCommGroup F
f✝ f' : G → E
g✝ g' : G → E'
x x' : G
y y' : E
inst✝¹⁴ : RCLike 𝕜
inst✝¹³ : NormedSpace 𝕜 E
inst✝¹² : NormedSpace 𝕜 E'
inst✝¹¹ : NormedSpace 𝕜 E''
inst✝¹⁰ : NormedSpace ℝ F
inst✝⁹ : NormedSpace 𝕜 F
inst✝⁸ : CompleteSpace F
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : BorelSpace G
inst✝⁴ : NormedSpace 𝕜 G
inst✝³ : NormedAddCommGroup P
inst✝² : NormedSpace 𝕜 P
μ : Measure G
L✝ : E →L[𝕜] E' →L[𝕜] F
inst✝¹ : μ.IsAddLeftInvariant
inst✝ : μ.IsNegInvariant
L : E' →L[𝕜] E →L[𝕜] F
f : G → E
n : ℕ∞
g : P → G → E'
s : Set P
k : Set G
hs : IsOpen s
hk : IsCompact k
hgs : ∀ (p : P) (x : G), p ∈ s → x ∉ k → g p x = 0
hf : LocallyIntegrable f μ
hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)
⊢ ContDiffOn 𝕜 n (fun q => (g q.1 ⋆[L, μ] f) q.2) (s ×ˢ univ)
state_after: no goals
Theorem: Fintype.choose_subtype_eq
File: Mathlib/Data/Fintype/Basic.lean

tactic: simpa [Subtype.ext_iff] using hy
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
p✝ : α✝ → Prop
inst✝² : DecidablePred p✝
α : Type u_4
p : α → Prop
inst✝¹ : Fintype { a // p a }
inst✝ : DecidableEq α
x y : { a // p a }
hy : (fun a => ↑a = ↑x) y
⊢ y = x
state_after: no goals

tactic: rw [Subtype.ext_iff, Fintype.choose_spec (fun y : { a : α // p a } => (y : α) = x) _]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α✝
p✝ : α✝ → Prop
inst✝² : DecidablePred p✝
α : Type u_4
p : α → Prop
inst✝¹ : Fintype { a // p a }
inst✝ : DecidableEq α
x : { a // p a }
h : optParam (∃! a, ↑a = ↑x) ⋯
⊢ choose (fun y => ↑y = ↑x) h = x
state_after: no goals
Theorem: BialgebraCat.Hom.toBialgHom_injective
File: Mathlib/Algebra/Category/BialgebraCat/Basic.lean

tactic: congr
state_before: R : Type u
inst✝ : CommRing R
V W : BialgebraCat R
x✝² x✝¹ : V.Hom W
f g : ↑V.toBundled →ₐc[R] ↑W.toBundled
x✝ : { toBialgHom := f }.toBialgHom = { toBialgHom := g }.toBialgHom
⊢ { toBialgHom := f } = { toBialgHom := g }
state_after: no goals
Theorem: MeasureTheory.tilted_of_not_integrable
File: Mathlib/MeasureTheory/Measure/Tilted.lean

tactic: rw [Measure.tilted, integral_undef hf]
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ μ.tilted f = 0
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / 0)) = 0

tactic: simp
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / 0)) = 0
state_after: no goals
Theorem: le_levenshtein_cons
File: Mathlib/Data/List/EditDistance/Bounds.lean

tactic: simpa [suffixLevenshtein_eq_tails_map, List.minimum_le_coe_iff] using
  suffixLevenshtein_minimum_le_levenshtein_cons (δ := δ) xs y ys
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
C : Levenshtein.Cost α β δ
inst✝ : CanonicallyLinearOrderedAddCommMonoid δ
xs : List α
y : β
ys : List β
⊢ ∃ xs', xs' <:+ xs ∧ levenshtein C xs' ys ≤ levenshtein C xs (y :: ys)
state_after: no goals
Theorem: Set.encard_ne_zero
File: Mathlib/Data/Set/Card.lean

tactic: rw [ne_eq, encard_eq_zero, nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type u_2
s t : Set α
⊢ s.encard ≠ 0 ↔ s.Nonempty
state_after: no goals
Theorem: Set.image_update_Ico_left
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simpa using image_update_Ico f i a (f i)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' Ico a (f i) = Ico (update f i a) f
state_after: no goals
Theorem: Multiset.inter_add_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_contra h
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s ∩ t + u = (s + u) ∩ (t + u)
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
⊢ False

tactic: cases'
  lt_iff_cons_le.1
    (lt_of_le_of_ne
      (le_inter (add_le_add_right (inter_le_left s t) u)
        (add_le_add_right (inter_le_right s t) u))
      h) with
  a hl
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
⊢ False
state_after: case intro
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ (s ∩ t + u) ≤ (s + u) ∩ (t + u)
⊢ False

tactic: rw [← cons_add] at hl
state_before: case intro
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ (s ∩ t + u) ≤ (s + u) ∩ (t + u)
⊢ False
state_after: case intro
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ s ∩ t + u ≤ (s + u) ∩ (t + u)
⊢ False

tactic: exact
  not_le_of_lt (lt_cons_self (s ∩ t) a)
    (le_inter (le_of_add_le_add_right (le_trans hl (inter_le_left _ _)))
      (le_of_add_le_add_right (le_trans hl (inter_le_right _ _))))
state_before: case intro
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ s ∩ t + u ≤ (s + u) ∩ (t + u)
⊢ False
state_after: no goals
Theorem: Polynomial.cardPowDegree_apply
File: Mathlib/Algebra/Polynomial/Degree/CardPowDegree.lean

tactic: rw [cardPowDegree]
state_before: Fq : Type u_1
inst✝² : Field Fq
inst✝¹ : Fintype Fq
inst✝ : DecidableEq Fq
p : Fq[X]
⊢ cardPowDegree p = if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree
state_after: Fq : Type u_1
inst✝² : Field Fq
inst✝¹ : Fintype Fq
inst✝ : DecidableEq Fq
p : Fq[X]
⊢ (let_fun card_pos := ⋯;
      let_fun pow_pos := ⋯;
      { toFun := fun p => if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree, map_mul' := ⋯, nonneg' := ⋯,
        eq_zero' := ⋯, add_le' := ⋯ })
      p =
    if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree

tactic: dsimp
state_before: Fq : Type u_1
inst✝² : Field Fq
inst✝¹ : Fintype Fq
inst✝ : DecidableEq Fq
p : Fq[X]
⊢ (let_fun card_pos := ⋯;
      let_fun pow_pos := ⋯;
      { toFun := fun p => if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree, map_mul' := ⋯, nonneg' := ⋯,
        eq_zero' := ⋯, add_le' := ⋯ })
      p =
    if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree
state_after: Fq : Type u_1
inst✝² : Field Fq
inst✝¹ : Fintype Fq
inst✝ : DecidableEq Fq
p : Fq[X]
⊢ (if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree) = if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree

tactic: convert rfl
state_before: Fq : Type u_1
inst✝² : Field Fq
inst✝¹ : Fintype Fq
inst✝ : DecidableEq Fq
p : Fq[X]
⊢ (if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree) = if p = 0 then 0 else ↑(Fintype.card Fq) ^ p.natDegree
state_after: no goals
Theorem: dvd_sub_left
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

tactic: simpa only [← sub_eq_add_neg] using dvd_add_left ((dvd_neg (α := α)).2 h)
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ c
⊢ a ∣ b - c ↔ a ∣ b
state_after: no goals
Theorem: EuclideanDomain.zero_div
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: simpa only [zero_mul] using mul_div_cancel_right₀ 0 a0
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
a0 : ¬a = 0
⊢ 0 / a = 0
state_after: no goals
Theorem: FreeAlgebra.lift_unique
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [← (lift R).symm_apply_eq, lift]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔ g = (lift R) f
state_after: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ }.symm g = f

tactic: rfl
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
g : FreeAlgebra R X →ₐ[R] A
⊢ ⇑g ∘ ι R = f ↔
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ }.symm g = f
state_after: no goals
Theorem: Matrix.neg_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
⊢ -A *ᵥ v = -(A *ᵥ v)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
x✝ : m
⊢ (-A *ᵥ v) x✝ = (-(A *ᵥ v)) x✝

tactic: apply neg_dotProduct
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
x✝ : m
⊢ (-A *ᵥ v) x✝ = (-(A *ᵥ v)) x✝
state_after: no goals
Theorem: CategoryTheory.Subobject.ofMkLE_comp_ofLE
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp only [ofMkLE, ofLEMk, ofLE, ofMkLEMk, ← Functor.map_comp underlying,
  assoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
X Y : Subobject B
h₁ : mk f ≤ X
h₂ : X ≤ Y
⊢ ofMkLE f X h₁ ≫ X.ofLE Y h₂ = ofMkLE f Y ⋯
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
X Y : Subobject B
h₁ : mk f ≤ X
h₂ : X ≤ Y
⊢ (underlyingIso f).inv ≫ underlying.map (h₁.hom ≫ h₂.hom) = (underlyingIso f).inv ≫ underlying.map ⋯.hom

tactic: congr 1
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A₁ : C
f : A₁ ⟶ B
inst✝ : Mono f
X Y : Subobject B
h₁ : mk f ≤ X
h₂ : X ≤ Y
⊢ (underlyingIso f).inv ≫ underlying.map (h₁.hom ≫ h₂.hom) = (underlyingIso f).inv ≫ underlying.map ⋯.hom
state_after: no goals
Theorem: List.formPerm_pow_apply_head
File: Mathlib/GroupTheory/Perm/List.lean

tactic: convert formPerm_pow_apply_get _ h n ⟨0, Nat.succ_pos _⟩
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : (x :: l).Nodup
n : ℕ
⊢ ((x :: l).formPerm ^ n) x = (x :: l).get ⟨n % (x :: l).length, ⋯⟩
state_after: case h.e'_3.h.e'_3.h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : (x :: l).Nodup
n : ℕ
⊢ n = ↑⟨0, ⋯⟩ + n

tactic: simp
state_before: case h.e'_3.h.e'_3.h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : (x :: l).Nodup
n : ℕ
⊢ n = ↑⟨0, ⋯⟩ + n
state_after: no goals
Theorem: String.length_replicate
File: Mathlib/Data/String/Lemmas.lean

tactic: simp only [String.length, String.replicate, List.length_replicate]
state_before: n : ℕ
c : Char
⊢ (replicate n c).length = n
state_after: no goals
Theorem: AddCommGroup.zsmul_modEq_zero
File: Mathlib/Algebra/ModEq.lean

tactic: simp
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z✝ z : ℤ
⊢ 0 - z • p = -z • p
state_after: no goals
Theorem: NNRat.cast_nonneg
File: Mathlib/Algebra/Order/Nonneg/Field.lean

tactic: rw [cast_def]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
⊢ 0 ≤ ↑q
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
⊢ 0 ≤ ↑q.num / ↑q.den

tactic: exact div_nonneg q.num.cast_nonneg q.den.cast_nonneg
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a : α
q : ℚ≥0
⊢ 0 ≤ ↑q.num / ↑q.den
state_after: no goals
Theorem: Disjoint.edgeSet
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simpa using edgeSet_mono h.le_bot
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
H₁ H₂ : G.Subgraph
h : Disjoint H₁ H₂
⊢ H₁.edgeSet ⊓ H₂.edgeSet ≤ ⊥
state_after: no goals
Theorem: Pretrivialization.ext
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: ext1 <;> [ext1; exact h₃]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
⊢ e = e'
state_after: case h₁.h
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
x✝ : Z
⊢ ↑e.toPartialEquiv x✝ = ↑e'.toPartialEquiv x✝

case h₁.hsymm
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
x✝ : B × F
⊢ ↑e.symm x✝ = ↑e'.symm x✝

case h₁.hs
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
⊢ e.source = e'.source

tactic: apply h₁
state_before: case h₁.h
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
x✝ : Z
⊢ ↑e.toPartialEquiv x✝ = ↑e'.toPartialEquiv x✝
state_after: no goals

tactic: apply h₂
state_before: case h₁.hsymm
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
x✝ : B × F
⊢ ↑e.symm x✝ = ↑e'.symm x✝
state_after: no goals

tactic: rw [e.source_eq, e'.source_eq, h₃]
state_before: case h₁.hs
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑e.symm x = ↑e'.symm x
h₃ : e.baseSet = e'.baseSet
⊢ e.source = e'.source
state_after: no goals
Theorem: Module.End.ker_pow_constant
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: simp
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
⊢ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ (k + 0))
state_after: no goals

tactic: apply le_antisymm
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ k) = LinearMap.ker (f ^ (k + (m + 1)))
state_after: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (k + (m + 1)))

case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ (k + (m + 1))) ≤ LinearMap.ker (f ^ k)

tactic: rw [add_comm, pow_add]
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (k + (m + 1)))
state_after: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (m + 1) * f ^ k)

tactic: apply LinearMap.ker_le_ker_comp
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ k) ≤ LinearMap.ker (f ^ (m + 1) * f ^ k)
state_after: no goals

tactic: rw [ker_pow_constant h m, add_comm m 1, ← add_assoc, pow_add, pow_add f k m,
  LinearMap.mul_eq_comp, LinearMap.mul_eq_comp, LinearMap.ker_comp, LinearMap.ker_comp, h,
  Nat.add_one]
state_before: case a
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
k : ℕ
h : LinearMap.ker (f ^ k) = LinearMap.ker (f ^ k.succ)
m : ℕ
⊢ LinearMap.ker (f ^ (k + (m + 1))) ≤ LinearMap.ker (f ^ k)
state_after: no goals
Theorem: WithBot.unbot'_eq_self_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [unbot'_eq_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b d : α
x : WithBot α
⊢ unbot' d x = d ↔ x = ↑d ∨ x = ⊥
state_after: no goals
Theorem: DoubleCentralizer.norm_snd
File: Mathlib/Analysis/NormedSpace/Star/Multiplier.lean

tactic: rw [← norm_fst, norm_fst_eq_snd]
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NonUnitalNormedRing A
inst✝⁴ : NormedSpace 𝕜 A
inst✝³ : SMulCommClass 𝕜 A A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : StarRing A
inst✝ : CstarRing A
a : 𝓜(𝕜, A)
⊢ ‖a.toProd.2‖ = ‖a‖
state_after: no goals
Theorem: OreLocalization.add_left_neg
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction' x with r s
state_before: R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddGroup X
inst✝ : DistribMulAction R X
x : OreLocalization S X
⊢ -x + x = 0
state_after: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddGroup X
inst✝ : DistribMulAction R X
r : X
s : ↥S
⊢ -(r /ₒ s) + r /ₒ s = 0

tactic: simp
state_before: case c
R : Type u_1
inst✝³ : Monoid R
S : Submonoid R
inst✝² : OreSet S
X : Type u_2
inst✝¹ : AddGroup X
inst✝ : DistribMulAction R X
r : X
s : ↥S
⊢ -(r /ₒ s) + r /ₒ s = 0
state_after: no goals
Theorem: CocompactMap.isCompact_preimage_of_isClosed
File: Mathlib/Topology/ContinuousFunction/CocompactMap.lean

tactic: obtain ⟨t, ht, hts⟩ :=
  mem_cocompact'.mp
    (by
      simpa only [preimage_image_preimage, preimage_compl] using
        mem_map.mp
          (cocompact_tendsto f <|
            mem_cocompact.mpr ⟨s, hs, compl_subset_compl.mpr (image_preimage_subset f _)⟩))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : CocompactMap α β
s : Set β
hs : IsCompact s
h's : IsClosed s
⊢ IsCompact (⇑f ⁻¹' s)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : CocompactMap α β
s : Set β
hs : IsCompact s
h's : IsClosed s
t : Set α
ht : IsCompact t
hts : (⇑f ⁻¹' s)ᶜᶜ ⊆ t
⊢ IsCompact (⇑f ⁻¹' s)

tactic: exact
  ht.of_isClosed_subset (h's.preimage <| map_continuous f) (by simpa using hts)
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : CocompactMap α β
s : Set β
hs : IsCompact s
h's : IsClosed s
t : Set α
ht : IsCompact t
hts : (⇑f ⁻¹' s)ᶜᶜ ⊆ t
⊢ IsCompact (⇑f ⁻¹' s)
state_after: no goals

tactic: simpa only [preimage_image_preimage, preimage_compl] using
  mem_map.mp
    (cocompact_tendsto f <|
      mem_cocompact.mpr ⟨s, hs, compl_subset_compl.mpr (image_preimage_subset f _)⟩)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : CocompactMap α β
s : Set β
hs : IsCompact s
h's : IsClosed s
⊢ ?m.7992 ∈ cocompact ?m.7965
state_after: no goals

tactic: simpa using hts
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : CocompactMap α β
s : Set β
hs : IsCompact s
h's : IsClosed s
t : Set α
ht : IsCompact t
hts : (⇑f ⁻¹' s)ᶜᶜ ⊆ t
⊢ ⇑f ⁻¹' s ⊆ t
state_after: no goals
Theorem: Set.not_ordConnected_inter_Icc_iff
File: Mathlib/Order/Interval/Set/OrdConnected.lean

tactic: simp_rw [ordConnected_inter_Icc_iff hx hy, subset_def, not_forall, exists_prop, and_comm]
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ ¬(s ∩ Icc x y).OrdConnected ↔ ∃ z ∉ s, z ∈ Ioo x y
state_after: no goals
Theorem: Polynomial.coeff_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: simp [coeff, Finsupp.single_apply]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ((monomial n) a).coeff m = if n = m then a else 0
state_after: no goals
Theorem: jacobiSym.quadratic_reciprocity_if
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: rcases Nat.odd_mod_four_iff.mp ha2 with ha1 | ha3
state_before: a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: case inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha1 : a % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

case inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

tactic: rcases Nat.odd_mod_four_iff.mp hb2 with hb1 | hb3
state_before: case inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: case inr.inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb1 : b % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

case inr.inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb3 : b % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)

tactic: simpa [ha3, hb3] using (jacobiSym.quadratic_reciprocity_three_mod_four ha3 hb3).symm
state_before: case inr.inr
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb3 : b % 4 = 3
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: no goals

tactic: simpa [ha1] using jacobiSym.quadratic_reciprocity_one_mod_four' (Nat.odd_iff.mpr hb2) ha1
state_before: case inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha1 : a % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: no goals

tactic: simpa [hb1] using jacobiSym.quadratic_reciprocity_one_mod_four hb1 (Nat.odd_iff.mpr ha2)
state_before: case inr.inl
a b : ℕ
ha2 : a % 2 = 1
hb2 : b % 2 = 1
ha3 : a % 4 = 3
hb1 : b % 4 = 1
⊢ (if a % 4 = 3 ∧ b % 4 = 3 then -J(↑b | a) else J(↑b | a)) = J(↑a | b)
state_after: no goals