1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SchwartzMap.decay_add_le_aux
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

tactic: rw [← mul_add]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤
    ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖x‖ ^ k * (‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖)

tactic: refine mul_le_mul_of_nonneg_left ?_ (by positivity)
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖x‖ ^ k * (‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖)
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖

tactic: rw [iteratedFDeriv_add_apply (f.smooth _) (g.smooth _)]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f + ⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f) x + iteratedFDeriv ℝ n (⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖

tactic: exact norm_add_le _ _
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ ‖iteratedFDeriv ℝ n (⇑f) x + iteratedFDeriv ℝ n (⇑g) x‖ ≤ ‖iteratedFDeriv ℝ n (⇑f) x‖ + ‖iteratedFDeriv ℝ n (⇑g) x‖
state_after: no goals

tactic: positivity
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
k n : ℕ
f g : 𝓢(E, F)
x : E
⊢ 0 ≤ ‖x‖ ^ k
state_after: no goals
Theorem: Multiset.aestronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rcases l with ⟨l⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : Multiset (α → M)
hl : ∀ f ∈ l, AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable l.prod μ
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l)) μ

tactic: simpa using l.aestronglyMeasurable_prod' (by simpa using hl)
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l)) μ
state_after: no goals

tactic: simpa using hl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_5
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ f ∈ Quot.mk Setoid.r l, AEStronglyMeasurable f μ
⊢ ∀ f ∈ l, AEStronglyMeasurable f μ
state_after: no goals
Theorem: Asymptotics.SuperpolynomialDecay.inv_param_mul
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa using hf.param_zpow_mul hk (-1)
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
hf : SuperpolynomialDecay l k f
⊢ SuperpolynomialDecay l k (k⁻¹ * f)
state_after: no goals
Theorem: ENNReal.toNNReal_eq_toNNReal_iff'
File: Mathlib/Data/ENNReal/Basic.lean

tactic: simp only [ENNReal.toNNReal_eq_toNNReal_iff x y, hx, hy, and_false, false_and, or_false]
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
hx : x ≠ ⊤
hy : y ≠ ⊤
⊢ x.toNNReal = y.toNNReal ↔ x = y
state_after: no goals
Theorem: Part.assert_pos
File: Mathlib/Data/Part.lean

tactic: dsimp [assert]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
⊢ assert p f = f h
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } = f h

tactic: cases h' : f h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } = f h
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } = { Dom := Dom✝, get := get✝ }

tactic: simp only [h', mk.injEq, h, exists_prop_of_true, true_and]
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } = { Dom := Dom✝, get := get✝ }
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ HEq (fun ha => get✝ ⋯) get✝

tactic: apply Function.hfunext
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ HEq (fun ha => get✝ ⋯) get✝
state_after: case mk.hα
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ (∃ (h : p), (f h).Dom) = Dom✝

case mk.h
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ ∀ (a : ∃ (h : p), (f h).Dom) (a' : Dom✝), HEq a a' → HEq (get✝ ⋯) (get✝ a')

tactic: simp only [h, h', exists_prop_of_true]
state_before: case mk.hα
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ (∃ (h : p), (f h).Dom) = Dom✝
state_after: no goals

tactic: aesop
state_before: case mk.h
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : p
Dom✝ : Prop
get✝ : Dom✝ → α
h' : f h = { Dom := Dom✝, get := get✝ }
⊢ ∀ (a : ∃ (h : p), (f h).Dom) (a' : Dom✝), HEq a a' → HEq (get✝ ⋯) (get✝ a')
state_after: no goals
Theorem: WeierstrassCurve.Affine.baseChange_negY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: erw [← map_negY, map_baseChange]
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y : A
⊢ (baseChange W B).toAffine.negY (f x) (f y) = f ((baseChange W A).toAffine.negY x y)
state_after: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y : A
⊢ (baseChange W B).toAffine.negY (f x) (f y) = (baseChange W B).toAffine.negY (f.toRingHom x) (f.toRingHom y)

tactic: rfl
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y : A
⊢ (baseChange W B).toAffine.negY (f x) (f y) = (baseChange W B).toAffine.negY (f.toRingHom x) (f.toRingHom y)
state_after: no goals
Theorem: CliffordAlgebra.contractLeft_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: refine (foldr'_ι _ _ ?_ _ _).trans <| by
  simp_rw [contractLeftAux_apply_apply, mul_zero, sub_zero,
    Algebra.algebraMap_eq_smul_one]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : M
⊢ (contractLeft d) ((ι Q) x) = (algebraMap R (CliffordAlgebra Q)) (d x)
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : M
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx

tactic: exact fun m x fx ↦ contractLeftAux_contractLeftAux Q d m x fx
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : M
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx
state_after: no goals

tactic: simp_rw [contractLeftAux_apply_apply, mul_zero, sub_zero,
  Algebra.algebraMap_eq_smul_one]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
x : M
⊢ ((contractLeftAux Q d) x) (1, 0) = (algebraMap R (CliffordAlgebra Q)) (d x)
state_after: no goals
Theorem: WeierstrassCurve.Affine.slope_of_Y_ne
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rw [slope, if_pos hx, if_neg hy]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
hx : x₁ = x₂
hy : y₁ ≠ W.negY x₂ y₂
⊢ W.slope x₁ x₂ y₁ y₂ = (3 * x₁ ^ 2 + 2 * W.a₂ * x₁ + W.a₄ - W.a₁ * y₁) / (y₁ - W.negY x₁ y₁)
state_after: no goals
Theorem: List.ofFnRec_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: have := (@equivSigmaTuple α).rightInverse_symm
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse ⇑equivSigmaTuple.symm ⇑equivSigmaTuple
⊢ ofFnRec h (ofFn f) = h n f

tactic: dsimp [equivSigmaTuple] at this
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse ⇑equivSigmaTuple.symm ⇑equivSigmaTuple
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
⊢ ofFnRec h (ofFn f) = h n f

tactic: have := this.cast_eq (fun s => h s.1 s.2) ⟨n, f⟩
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this :
  cast ⋯
      (h ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.fst ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.snd) =
    h ⟨n, f⟩.fst ⟨n, f⟩.snd
⊢ ofFnRec h (ofFn f) = h n f

tactic: dsimp only at this
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this :
  cast ⋯
      (h ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.fst ⟨(ofFn ⟨n, f⟩.snd).length, (ofFn ⟨n, f⟩.snd).get⟩.snd) =
    h ⟨n, f⟩.fst ⟨n, f⟩.snd
⊢ ofFnRec h (ofFn f) = h n f
state_after: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this : cast ⋯ (h (ofFn f).length (ofFn f).get) = h n f
⊢ ofFnRec h (ofFn f) = h n f

tactic: rw [ofFnRec, ← this]
state_before: α : Type u
C : List α → Sort u_1
h : (n : ℕ) → (f : Fin n → α) → C (ofFn f)
n : ℕ
f : Fin n → α
this✝ : Function.RightInverse (fun f => ofFn f.snd) fun l => ⟨l.length, l.get⟩
this : cast ⋯ (h (ofFn f).length (ofFn f).get) = h n f
⊢ ofFnRec h (ofFn f) = h n f
state_after: no goals
Theorem: Filter.Tendsto.partialSups_apply
File: Mathlib/Topology/Order/PartialSups.lean

tactic: simpa only [← partialSups_apply] using Tendsto.partialSups hf
state_before: L : Type u_1
inst✝² : SemilatticeSup L
inst✝¹ : TopologicalSpace L
inst✝ : ContinuousSup L
α : Type u_2
l : Filter α
f : ℕ → α → L
g : ℕ → L
n : ℕ
hf : ∀ k ≤ n, Tendsto (f k) l (𝓝 (g k))
⊢ Tendsto (fun a => (partialSups fun x => f x a) n) l (𝓝 ((partialSups g) n))
state_after: no goals
Theorem: Fin.image_succAbove_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext m
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
i : Fin (n + 1)
⊢ image i.succAbove univ = {i}ᶜ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
i m : Fin (n + 1)
⊢ m ∈ image i.succAbove univ ↔ m ∈ {i}ᶜ

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
i m : Fin (n + 1)
⊢ m ∈ image i.succAbove univ ↔ m ∈ {i}ᶜ
state_after: no goals
Theorem: CategoryTheory.Cat.rightUnitor_hom_app
File: Mathlib/CategoryTheory/Category/Cat.lean

tactic: simp
state_before: B C : Cat
F : B ⟶ C
X : ↑B
⊢ (F ≫ 𝟙 C).obj X = F.obj X
state_after: no goals
Theorem: Cardinal.small_iff_lift_mk_lt_univ
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [lt_univ']
state_before: α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ Small.{v, u} α ↔ lift.{v + 1, u} #α < univ.{v, max u (v + 1)}
state_after: α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ Small.{v, u} α ↔ ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'

tactic: constructor
state_before: α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ Small.{v, u} α ↔ ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'
state_after: case mp
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ Small.{v, u} α → ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'

case mpr
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ (∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c') → Small.{v, u} α

tactic: rintro ⟨β, e⟩
state_before: case mp
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ Small.{v, u} α → ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'
state_after: case mp.mk.intro
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
e : Nonempty (α ≃ β)
⊢ ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'

tactic: exact ⟨#β, lift_mk_eq.{u, _, v + 1}.2 e⟩
state_before: case mp.mk.intro
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α : Type u
β : Type v
e : Nonempty (α ≃ β)
⊢ ∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c'
state_after: no goals

tactic: rintro ⟨c, hc⟩
state_before: case mpr
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
⊢ (∃ c', lift.{v + 1, u} #α = lift.{max u (v + 1), v} c') → Small.{v, u} α
state_after: case mpr.intro
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
c : Cardinal.{v}
hc : lift.{v + 1, u} #α = lift.{max u (v + 1), v} c
⊢ Small.{v, u} α

tactic: exact ⟨⟨c.out, lift_mk_eq.{u, _, v + 1}.1 (hc.trans (congr rfl c.mk_out.symm))⟩⟩
state_before: case mpr.intro
α✝ : Type u
β : Type u_1
γ : Type u_2
r : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
α : Type u
c : Cardinal.{v}
hc : lift.{v + 1, u} #α = lift.{max u (v + 1), v} c
⊢ Small.{v, u} α
state_after: no goals
Theorem: lp.isLUB_norm
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [lp.norm_eq_ciSup]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) ‖f‖
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) (⨆ i, ‖↑f i‖)

tactic: exact isLUB_ciSup (lp.memℓp f)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) (⨆ i, ‖↑f i‖)
state_after: no goals
Theorem: List.permutationsAux2_snd_eq
File: Mathlib/Data/List/Permutation.lean

tactic: rw [← permutationsAux2_append, map_permutationsAux2, permutationsAux2_comp_append]
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
r : List β
ys : List α
f : List α → β
⊢ (permutationsAux2 t ts r ys f).2 = map (fun x => f (x ++ ts)) (permutationsAux2 t [] [] ys id).2 ++ r
state_after: no goals
Theorem: LinearMap.BilinForm.tensorDistribEquiv_toLinearMap
File: Mathlib/LinearAlgebra/BilinearForm/TensorProduct.lean

tactic: ext B₁ B₂ : 3
state_before: ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
⊢ ↑(tensorDistribEquiv R) = tensorDistrib R R
state_after: case a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ ((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂ = ((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂

tactic: ext
state_before: case a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ ((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂ = ((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂
state_after: case a.h.h.a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
x✝³ : M₁
x✝² : M₂
x✝¹ : M₁
x✝ : M₂
⊢ ((AlgebraTensorModule.curry
          (((AlgebraTensorModule.curry (((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂)) x✝³) x✝²))
        x✝¹)
      x✝ =
    ((AlgebraTensorModule.curry
          (((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂)) x✝³) x✝²))
        x✝¹)
      x✝

tactic: exact mul_comm _ _
state_before: case a.h.h.a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
x✝³ : M₁
x✝² : M₂
x✝¹ : M₁
x✝ : M₂
⊢ ((AlgebraTensorModule.curry
          (((AlgebraTensorModule.curry (((AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂)) x✝³) x✝²))
        x✝¹)
      x✝ =
    ((AlgebraTensorModule.curry
          (((AlgebraTensorModule.curry (((AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂)) x✝³) x✝²))
        x✝¹)
      x✝
state_after: no goals
Theorem: multiplicity.get_multiplicity_self
File: Mathlib/RingTheory/Multiplicity.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
⊢ a ^ 1 ∣ a
state_after: no goals

tactic: rw [← mul_one a, pow_add, pow_one, mul_assoc, mul_assoc,
    mul_right_inj' (ne_zero_of_finite ha)] at hb
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : a = a ^ (1 + 1) * b
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : 1 = 1 * (a * 1 * b)
⊢ False

tactic: exact
  mt isUnit_iff_dvd_one.2 (not_unit_of_finite ha) ⟨b, by simp_all⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : 1 = 1 * (a * 1 * b)
⊢ False
state_after: no goals

tactic: simp_all
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : Finite a a
x✝ : a ^ (1 + 1) ∣ a
b : α
hb : 1 = 1 * (a * 1 * b)
⊢ 1 = a * b
state_after: no goals
Theorem: Filter.extraction_of_frequently_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [frequently_atTop'] at h
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∃ᶠ (n : ℕ) in atTop, P n
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∀ (a : ℕ), ∃ b > a, P b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)

tactic: exact extraction_of_frequently_atTop' h
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
P : ℕ → Prop
h : ∀ (a : ℕ), ∃ b > a, P b
⊢ ∃ φ, StrictMono φ ∧ ∀ (n : ℕ), P (φ n)
state_after: no goals