tasksource/leandojo huggingface dataset:
Theorem: isIntegrallyClosed_iff_isIntegralClosure
File: Mathlib/RingTheory/IntegrallyClosed.lean

tactic: constructor
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ (∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x) ↔ IsIntegralClosure R R K

tactic: intro cl
state_before: case mp
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ (∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x) → IsIntegralClosure R R K

tactic: refine' ⟨IsFractionRing.injective R K, ⟨cl, _⟩⟩
state_before: case mp
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
cl : ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x
⊢ IsIntegralClosure R R K

tactic: rintro ⟨y, y_eq⟩
state_before: case mp
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
cl : ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x
x✝ : K
⊢ (∃ y, ↑(algebraMap R K) y = x✝) → IsIntegral R x✝

tactic: rw [← y_eq]
state_before: case mp.intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
cl : ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x
x✝ : K
y : R
y_eq : ↑(algebraMap R K) y = x✝
⊢ IsIntegral R x✝

tactic: exact isIntegral_algebraMap
state_before: case mp.intro
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
cl : ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x
x✝ : K
y : R
y_eq : ↑(algebraMap R K) y = x✝
⊢ IsIntegral R (↑(algebraMap R K) y)

tactic: rintro ⟨-, cl⟩ x hx
state_before: case mpr
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ IsIntegralClosure R R K → ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x

tactic: exact cl.mp hx
state_before: case mpr.mk
R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
cl : ∀ {x : K}, IsIntegral R x ↔ ∃ y, ↑(algebraMap R K) y = x
x : K
hx : IsIntegral R x
⊢ ∃ y, ↑(algebraMap R K) y = x
Theorem: add_tsub_add_le_tsub_add_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [add_comm c, tsub_le_iff_left, add_assoc, ← tsub_le_iff_left, ← tsub_le_iff_left]
state_before: α : Type u_1
β : Type ?u.17481
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b - (c + d) ≤ a - c + (b - d)

tactic: refine' (tsub_le_tsub_right add_tsub_le_assoc c).trans _
state_before: α : Type u_1
β : Type ?u.17481
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + b - d - c ≤ a - c + (b - d)

tactic: rw [add_comm a, add_comm (a - c)]
state_before: α : Type u_1
β : Type ?u.17481
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ a + (b - d) - c ≤ a - c + (b - d)

tactic: exact add_tsub_le_assoc
state_before: α : Type u_1
β : Type ?u.17481
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ b - d + a - c ≤ b - d + (a - c)
Theorem: Pell.xn_modEq_x2n_add
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [two_mul, add_assoc, xn_add, add_assoc, ← zero_add 0]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 (2 * n + j) + xn a1 j ≡ 0 [MOD xn a1 n]

tactic: refine' (dvd_mul_right (xn a1 n) (xn a1 (n + j))).modEq_zero_nat.add _
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ xn a1 n * xn a1 (n + j) + (Pell.d a1 * yn a1 n * yn a1 (n + j) + xn a1 j) ≡ 0 + 0 [MOD xn a1 n]

tactic: rw [yn_add, left_distrib, add_assoc, ← zero_add 0]
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ Pell.d a1 * yn a1 n * yn a1 (n + j) + xn a1 j ≡ 0 [MOD xn a1 n]

tactic: exact
  ((dvd_mul_right _ _).mul_left _).modEq_zero_nat.add (xn_modEq_x2n_add_lem _ _ _).modEq_zero_nat
state_before: a : ℕ
a1 : 1 < a
n j : ℕ
⊢ Pell.d a1 * yn a1 n * (xn a1 n * yn a1 j) + (Pell.d a1 * yn a1 n * (yn a1 n * xn a1 j) + xn a1 j) ≡ 0 + 0 [MOD
    xn a1 n]
Theorem: CategoryTheory.Limits.hasInitialChangeDiagram
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
F₁ : Discrete PEmpty ⥤ C
F₂ : Discrete PEmpty ⥤ C
h : HasColimit F₁
⊢ (X : Discrete PEmpty) → F₂.obj X ⟶ ((Functor.const (Discrete PEmpty)).obj (colimit F₁)).obj X

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
F₁ : Discrete PEmpty ⥤ C
F₂ : Discrete PEmpty ⥤ C
h : HasColimit F₁
⊢ ∀ ⦃X Y : Discrete PEmpty⦄ (f : X ⟶ Y),
    F₂.map f ≫ id (Discrete.casesOn Y fun as => False.elim (_ : False)) =
      id (Discrete.casesOn X fun as => False.elim (_ : False)) ≫
        ((Functor.const (Discrete PEmpty)).obj (colimit F₁)).map f
Theorem: Polynomial.zero_modByMonic
File: Mathlib/Data/Polynomial/Div.lean

tactic: unfold modByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ 0 %ₘ p = 0

tactic: dsimp
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ (if h : Monic p then
      (if h_1 : degree p ≤ degree 0 ∧ 0 ≠ 0 then
          let z := ↑C (leadingCoeff 0) * X ^ (natDegree 0 - natDegree p);
          let_fun _wf := (_ : degree (0 - ↑C (leadingCoeff 0) * X ^ (natDegree 0 - natDegree p) * p) < degree 0);
          let dm := divModByMonicAux (0 - z * p) (_ : Monic p);
          (z + dm.fst, dm.snd)
        else (0, 0)).snd
    else 0) =
    0

tactic: by_cases hp : Monic p
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).snd
    else 0) =
    0

tactic: rw [dif_pos hp, if_neg (mt And.right (not_not_intro rfl))]
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
hp : Monic p
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).snd
    else 0) =
    0

tactic: rw [dif_neg hp]
state_before: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
hp : ¬Monic p
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).snd
    else 0) =
    0
Theorem: Basis.map_equiv
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext i
state_before: ι : Type u_1
ι' : Type u_4
R : Type u_2
R₂ : Type ?u.557598
K : Type ?u.557601
M : Type u_3
M' : Type u_5
M'' : Type ?u.557610
V : Type u
V' : Type ?u.557615
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c : R
x : M
b'✝ : Basis ι' R M'
e✝ : ι ≃ ι'
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
b : Basis ι R M
b' : Basis ι' R M'
e : ι ≃ ι'
⊢ Basis.map b (Basis.equiv b b' e) = reindex b' e.symm

tactic: simp
state_before: case a
ι : Type u_1
ι' : Type u_4
R : Type u_2
R₂ : Type ?u.557598
K : Type ?u.557601
M : Type u_3
M' : Type u_5
M'' : Type ?u.557610
V : Type u
V' : Type ?u.557615
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b✝ b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b'✝ : Basis ι' R M'
e✝ : ι ≃ ι'
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
b : Basis ι R M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
⊢ ↑(Basis.map b (Basis.equiv b b' e)) i = ↑(reindex b' e.symm) i
Theorem: Submodule.sup_dualAnnihilator_le_inf
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [le_dualAnnihilator_iff_le_dualCoannihilator, dualCoannihilator_sup_eq]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ dualAnnihilator U ⊔ dualAnnihilator V ≤ dualAnnihilator (U ⊓ V)

tactic: apply inf_le_inf <;> exact le_dualAnnihilator_dualCoannihilator _
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U ⊓ V ≤ dualCoannihilator (dualAnnihilator U) ⊓ dualCoannihilator (dualAnnihilator V)
Theorem: isEmpty_subtype
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_subtype, not_exists]
state_before: α : Sort u_1
β : Sort ?u.2853
γ : Sort ?u.2856
p : α → Prop
⊢ IsEmpty (Subtype p) ↔ ∀ (x : α), ¬p x
Theorem: nnnorm_pow_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp only [Nat.zero_eq, pow_zero, nnnorm_one, le_rfl]
state_before: α : Type u_1
β : Type ?u.129705
γ : Type ?u.129708
ι : Type ?u.129711
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
a : α
n : ℕ
⊢ ‖a ^ Nat.zero‖₊ ≤ ‖a‖₊ ^ Nat.zero
Theorem: mul_left_mem_nonZeroDivisors_eq_zero_iff
File: Mathlib/RingTheory/NonZeroDivisors.lean

tactic: rw [mul_comm, mul_right_mem_nonZeroDivisors_eq_zero_iff hr]
state_before: M : Type ?u.12943
M' : Type ?u.12946
M₁ : Type u_1
R : Type ?u.12952
R' : Type ?u.12955
F : Type ?u.12958
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
r x : M₁
hr : r ∈ M₁⁰
⊢ r * x = 0 ↔ x = 0
Theorem: ContinuousLinearMap.continuous_integral_comp_L1
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← funext L.integral_compLp]
state_before: α : Type u_4
β : Type ?u.1299864
E : Type u_2
F : Type u_3
inst✝⁷ : MeasurableSpace α
ι : Type ?u.1299876
inst✝⁶ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
𝕜 : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : CompleteSpace F
inst✝ : NormedSpace ℝ F
L : E →L[𝕜] F
⊢ Continuous fun φ => ∫ (a : α), ↑L (↑↑φ a) ∂μ

tactic: exact continuous_integral.comp (L.compLpL 1 μ).continuous
state_before: α : Type u_4
β : Type ?u.1299864
E : Type u_2
F : Type u_3
inst✝⁷ : MeasurableSpace α
ι : Type ?u.1299876
inst✝⁶ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
𝕜 : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : CompleteSpace F
inst✝ : NormedSpace ℝ F
L : E →L[𝕜] F
⊢ Continuous fun x => ∫ (a : α), ↑↑(compLp L x) a ∂μ
Theorem: DoubleQuot.quotQuotEquivComm_symm
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: change (((quotQuotEquivQuotSup I J).trans (quotEquivOfEq (sup_comm))).trans
  (quotQuotEquivQuotSup J I).symm).symm =
    ((quotQuotEquivQuotSup J I).trans (quotEquivOfEq (sup_comm))).trans
      (quotQuotEquivQuotSup I J).symm
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
⊢ RingEquiv.symm (quotQuotEquivComm I J) = quotQuotEquivComm J I

tactic: ext r
state_before: R : Type u
inst✝ : CommRing R
I J : Ideal R
⊢ RingEquiv.symm
      (RingEquiv.trans (RingEquiv.trans (quotQuotEquivQuotSup I J) (quotEquivOfEq (_ : I ⊔ J = J ⊔ I)))
        (RingEquiv.symm (quotQuotEquivQuotSup J I))) =
    RingEquiv.trans (RingEquiv.trans (quotQuotEquivQuotSup J I) (quotEquivOfEq (_ : J ⊔ I = I ⊔ J)))
      (RingEquiv.symm (quotQuotEquivQuotSup I J))

tactic: dsimp
state_before: case h
R : Type u
inst✝ : CommRing R
I J : Ideal R
r : (R ⧸ J) ⧸ map (Ideal.Quotient.mk J) I
⊢ ↑(RingEquiv.symm
          (RingEquiv.trans (RingEquiv.trans (quotQuotEquivQuotSup I J) (quotEquivOfEq (_ : I ⊔ J = J ⊔ I)))
            (RingEquiv.symm (quotQuotEquivQuotSup J I))))
      r =
    ↑(RingEquiv.trans (RingEquiv.trans (quotQuotEquivQuotSup J I) (quotEquivOfEq (_ : J ⊔ I = I ⊔ J)))
          (RingEquiv.symm (quotQuotEquivQuotSup I J)))
      r

tactic: rfl
state_before: case h
R : Type u
inst✝ : CommRing R
I J : Ideal R
r : (R ⧸ J) ⧸ map (Ideal.Quotient.mk J) I
⊢ ↑(RingEquiv.symm (quotQuotEquivQuotSup I J))
      (↑(RingEquiv.symm (quotEquivOfEq (_ : I ⊔ J = J ⊔ I)))
        (↑(RingEquiv.symm (RingEquiv.symm (quotQuotEquivQuotSup J I))) r)) =
    ↑(RingEquiv.symm (quotQuotEquivQuotSup I J)) (↑(quotEquivOfEq (_ : J ⊔ I = I ⊔ J)) (↑(quotQuotEquivQuotSup J I) r))
Theorem: completeSpace_coe_iff_isComplete
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [Subtype.range_coe]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
s : Set α
⊢ IsComplete (range Subtype.val) ↔ IsComplete s
Theorem: le_mul_of_le_one_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_one] using mul_le_mul_of_nonpos_left h ha
state_before: α : Type u
β : Type ?u.41755
inst✝ : OrderedRing α
a b c d : α
ha : a ≤ 0
h : b ≤ 1
⊢ a ≤ a * b
Theorem: Equiv.Perm.cycleOf_apply_apply_zpow_self
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [SameCycle.cycleOf_apply]
state_before: ι : Type ?u.2245333
α : Type u_1
β : Type ?u.2245339
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
k : ℤ
⊢ ↑(cycleOf f x) (↑(f ^ k) x) = ↑(f ^ (k + 1)) x

tactic: rw [add_comm, zpow_add, zpow_one, mul_apply]
state_before: ι : Type ?u.2245333
α : Type u_1
β : Type ?u.2245339
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
k : ℤ
⊢ ↑f (↑(f ^ k) x) = ↑(f ^ (k + 1)) x

tactic: exact ⟨k, rfl⟩
state_before: ι : Type ?u.2245333
α : Type u_1
β : Type ?u.2245339
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
k : ℤ
⊢ SameCycle f x (↑(f ^ k) x)
Theorem: LocalHomeomorph.continuous_iff_continuous_comp_left
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: simp only [continuous_iff_continuousOn_univ]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.103511
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
f : γ → α
h : f ⁻¹' e.source = univ
⊢ Continuous f ↔ Continuous (↑e ∘ f)

tactic: exact e.continuousOn_iff_continuousOn_comp_left (Eq.symm h).subset
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
δ : Type ?u.103511
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
f : γ → α
h : f ⁻¹' e.source = univ
⊢ ContinuousOn f univ ↔ ContinuousOn (↑e ∘ f) univ
Theorem: WittVector.ghostFun_neg
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: ghost_fun_tac -X 0, ![x.coeff]
state_before: p : ℕ
R : Type u_1
S : Type ?u.743877
T : Type ?u.743880
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.743895
β : Type ?u.743898
x y : 𝕎 R
⊢ WittVector.ghostFun (-x) = -WittVector.ghostFun x
Theorem: map_mul_eq_one
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [← map_mul, h, map_one]
state_before: α : Type ?u.42893
β : Type ?u.42896
M : Type u_2
N : Type u_3
P : Type ?u.42905
G : Type ?u.42908
H : Type ?u.42911
F : Type u_1
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MonoidHomClass F M N
f : F
a b : M
h : a * b = 1
⊢ ↑f a * ↑f b = 1
Theorem: IsROrC.norm_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: simp only [← sqrt_normSq_eq_norm, normSq_conj]
state_before: K : Type u_1
E : Type ?u.6195800
inst✝ : IsROrC K
z : K
⊢ ‖↑(starRingEnd K) z‖ = ‖z‖
Theorem: Matrix.det_neg_eq_smul
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← det_smul_of_tower, Units.neg_smul, one_smul]
state_before: m : Type ?u.1378683
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
⊢ det (-A) = (-1) ^ Fintype.card n • det A
Theorem: dense_iInter_of_Gδ
File: Mathlib/Topology/MetricSpace/Baire.lean

tactic: rw [← sInter_range]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.22697
ι : Type ?u.22700
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsGδ (f s)
hd : ∀ (s : β), Dense (f s)
⊢ Dense (⋂ (s : β), f s)

tactic: exact dense_sInter_of_Gδ (forall_range_iff.2 ‹_›) (countable_range _) (forall_range_iff.2 ‹_›)
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.22697
ι : Type ?u.22700
inst✝² : TopologicalSpace α
inst✝¹ : BaireSpace α
inst✝ : Encodable β
f : β → Set α
ho : ∀ (s : β), IsGδ (f s)
hd : ∀ (s : β), Dense (f s)
⊢ Dense (⋂₀ range fun s => f s)
Theorem: EReal.sign_mul
File: Mathlib/Data/Real/EReal.lean

tactic: induction x, y using induction₂_symm_neg with
| top_zero => simp only [zero_mul, mul_zero, sign_zero]
| top_top => rfl
| symm h => rwa [mul_comm, EReal.mul_comm]
| coe_coe => simp only [← coe_mul, sign_coe, _root_.sign_mul, ENNReal.ofReal_mul (abs_nonneg _)]
| top_pos _ h =>
  rw [top_mul_coe_of_pos h, sign_top, one_mul, sign_pos (EReal.coe_pos.2 h)]
| neg_left h => rw [neg_mul, sign_neg, sign_neg, h, neg_mul]
state_before: x y : EReal
⊢ ↑sign (x * y) = ↑sign x * ↑sign y

tactic: simp only [zero_mul, mul_zero, sign_zero]
state_before: case top_zero

⊢ ↑sign (⊤ * 0) = ↑sign ⊤ * ↑sign 0

tactic: rfl
state_before: case top_top

⊢ ↑sign (⊤ * ⊤) = ↑sign ⊤ * ↑sign ⊤

tactic: rwa [mul_comm, EReal.mul_comm]
state_before: case symm
x✝ y✝ : EReal
h : ↑sign (x✝ * y✝) = ↑sign x✝ * ↑sign y✝
⊢ ↑sign (y✝ * x✝) = ↑sign y✝ * ↑sign x✝

tactic: simp only [← coe_mul, sign_coe, _root_.sign_mul, ENNReal.ofReal_mul (abs_nonneg _)]
state_before: case coe_coe
x✝ y✝ : ℝ
⊢ ↑sign (↑x✝ * ↑y✝) = ↑sign ↑x✝ * ↑sign ↑y✝

tactic: rw [top_mul_coe_of_pos h, sign_top, one_mul, sign_pos (EReal.coe_pos.2 h)]
state_before: case top_pos
x✝ : ℝ
h : 0 < x✝
⊢ ↑sign (⊤ * ↑x✝) = ↑sign ⊤ * ↑sign ↑x✝

tactic: rw [neg_mul, sign_neg, sign_neg, h, neg_mul]
state_before: case neg_left
x✝ y✝ : EReal
h : ↑sign (x✝ * y✝) = ↑sign x✝ * ↑sign y✝
⊢ ↑sign (-x✝ * y✝) = ↑sign (-x✝) * ↑sign y✝
Theorem: measurableSet_of_differentiableWithinAt_Ici
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: have : IsComplete (univ : Set F) := complete_univ
state_before: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x}

tactic: convert measurableSet_of_differentiableWithinAt_Ici_of_isComplete f this
state_before: F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x}

tactic: simp
state_before: case h.e'_3.h.e'_2.h.a
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : ℝ
⊢ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ↔ DifferentiableWithinAt ℝ f (Ici x✝) x✝ ∧ derivWithin f (Ici x✝) x✝ ∈ univ
Theorem: Multiset.prod_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.47547
δ : Type ?u.47550
a : α
s✝ t✝ : Multiset α
f g : α → Multiset β
inst✝ : CommMonoid β
s : Multiset α
t : α → Multiset β
⊢ prod (bind 0 t) = prod (map (fun a => prod (t a)) 0)

tactic: simp [ih, cons_bind]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.47547
δ : Type ?u.47550
a✝ : α
s✝¹ t✝ : Multiset α
f g : α → Multiset β
inst✝ : CommMonoid β
s✝ : Multiset α
t : α → Multiset β
a : α
s : Multiset α
ih : prod (bind s t) = prod (map (fun a => prod (t a)) s)
⊢ prod (bind (a ::ₘ s) t) = prod (map (fun a => prod (t a)) (a ::ₘ s))
Theorem: List.map_snd_zip
File: Mathlib/Data/List/Zip.lean

tactic: rw [zip_nil_right]
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
x✝¹ : List α
x✝ : length [] ≤ length x✝¹
⊢ map Prod.snd (zip x✝¹ []) = []

tactic: rfl
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
x✝¹ : List α
x✝ : length [] ≤ length x✝¹
⊢ map Prod.snd [] = []

tactic: simp at h
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
b : β
bs : List β
h : length (b :: bs) ≤ length []
⊢ map Prod.snd (zip [] (b :: bs)) = b :: bs

tactic: simp [succ_le_succ_iff] at h
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
a : α
as : List α
b : β
bs : List β
h : length (b :: bs) ≤ length (a :: as)
⊢ map Prod.snd (zip (a :: as) (b :: bs)) = b :: bs

tactic: change _ :: map Prod.snd (zip as bs) = _ :: bs
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
a : α
as : List α
b : β
bs : List β
h : length bs ≤ length as
⊢ map Prod.snd (zip (a :: as) (b :: bs)) = b :: bs

tactic: rw [map_snd_zip as bs h]
state_before: α : Type u
β : Type u_1
γ : Type ?u.83109
δ : Type ?u.83112
ε : Type ?u.83115
a : α
as : List α
b : β
bs : List β
h : length bs ≤ length as
⊢ (a, b).snd :: map Prod.snd (zip as bs) = b :: bs
Theorem: Real.inner_le_Lp_mul_Lq_tsum_of_nonneg
File: Mathlib/Analysis/MeanInequalities.lean

tactic: lift f to ι → ℝ≥0 using hf
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
hf : ∀ (i : ι), 0 ≤ f i
hg : ∀ (i : ι), 0 ≤ g i
hf_sum : Summable fun i => f i ^ p
hg_sum : Summable fun i => g i ^ q
⊢ (Summable fun i => f i * g i) ∧
    (∑' (i : ι), f i * g i) ≤ (∑' (i : ι), f i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)

tactic: lift g to ι → ℝ≥0 using hg
state_before: case intro
ι : Type u
s : Finset ι
g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
hg : ∀ (i : ι), 0 ≤ g i
hg_sum : Summable fun i => g i ^ q
f : ι → ℝ≥0
hf_sum : Summable fun i => (fun i => ↑(f i)) i ^ p
⊢ (Summable fun i => (fun i => ↑(f i)) i * g i) ∧
    (∑' (i : ι), (fun i => ↑(f i)) i * g i) ≤
      (∑' (i : ι), (fun i => ↑(f i)) i ^ p) ^ (1 / p) * (∑' (i : ι), g i ^ q) ^ (1 / q)

tactic: norm_cast  at *
state_before: case intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f : ι → ℝ≥0
hf_sum : Summable fun i => (fun i => ↑(f i)) i ^ p
g : ι → ℝ≥0
hg_sum : Summable fun i => (fun i => ↑(g i)) i ^ q
⊢ (Summable fun i => (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) ∧
    (∑' (i : ι), (fun i => ↑(f i)) i * (fun i => ↑(g i)) i) ≤
      (∑' (i : ι), (fun i => ↑(f i)) i ^ p) ^ (1 / p) * (∑' (i : ι), (fun i => ↑(g i)) i ^ q) ^ (1 / q)

tactic: exact NNReal.inner_le_Lp_mul_Lq_tsum hpq hf_sum hg_sum
state_before: case intro.intro
ι : Type u
s : Finset ι
p q : ℝ
hpq : IsConjugateExponent p q
f g : ι → ℝ≥0
hf_sum : Summable fun a => f a ^ p
hg_sum : Summable fun a => g a ^ q
⊢ (Summable fun a => f a * g a) ∧
    (∑' (a : ι), f a * g a) ≤ (∑' (a : ι), f a ^ p) ^ (1 / p) * (∑' (a : ι), g a ^ q) ^ (1 / q)
Theorem: Ordinal.add_omega
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: rcases lt_omega.1 h with ⟨n, rfl⟩
state_before: a : Ordinal
h : a < ω
⊢ a + ω = ω

tactic: clear h
state_before: case intro
n : ℕ
h : ↑n < ω
⊢ ↑n + ω = ω

tactic: induction' n with n IH
state_before: case intro
n : ℕ
⊢ ↑n + ω = ω

tactic: rw [Nat.cast_zero, zero_add]
state_before: case intro.zero

⊢ ↑Nat.zero + ω = ω

tactic: rwa [Nat.cast_succ, add_assoc, one_add_of_omega_le (le_refl _)]
state_before: case intro.succ
n : ℕ
IH : ↑n + ω = ω
⊢ ↑(Nat.succ n) + ω = ω