tasksource/leandojo huggingface dataset:
Theorem: Polynomial.multiplicity_le_one_of_separable
File: Mathlib/FieldTheory/Separable.lean

tactic: contrapose! hq
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hq : ¬IsUnit q
hsep : Separable p
⊢ multiplicity q p ≤ 1

tactic: apply isUnit_of_self_mul_dvd_separable hsep
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
⊢ IsUnit q

tactic: rw [← sq]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
⊢ q * q ∣ p

tactic: apply multiplicity.pow_dvd_of_le_multiplicity
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
⊢ q ^ 2 ∣ p

tactic: have h : ⟨Part.Dom 1 ∧ Part.Dom 1, fun _ ↦ 2⟩ ≤ multiplicity q p := PartENat.add_one_le_of_lt hq
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
⊢ ↑2 ≤ multiplicity q p

tactic: rw [and_self] at h
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
h : { Dom := 1.Dom ∧ 1.Dom, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p

tactic: exact h
state_before: case a
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q✝ : ℕ
p q : R[X]
hsep : Separable p
hq : 1 < multiplicity q p
h : { Dom := 1.Dom, get := fun x => 2 } ≤ multiplicity q p
⊢ ↑2 ≤ multiplicity q p
Theorem: YoungDiagram.get_rowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp only [rowLens, List.get_range, List.get_map]
state_before: μ : YoungDiagram
i : Fin (List.length (rowLens μ))
⊢ List.get (rowLens μ) i = rowLen μ ↑i
Theorem: Finset.map_add_left_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_inj, coe_map, coe_Ioc, coe_Ioc]
state_before: ι : Type ?u.221440
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addLeftEmbedding c) (Ioc a b) = Ioc (c + a) (c + b)

tactic: exact Set.image_const_add_Ioc _ _ _
state_before: ι : Type ?u.221440
α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ↑(addLeftEmbedding c) '' Set.Ioc a b = Set.Ioc (c + a) (c + b)
Theorem: pochhammer_eval_cast
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [← pochhammer_map (algebraMap ℕ S), eval_map, ← eq_natCast (algebraMap ℕ S), eval₂_at_nat_cast,
  Nat.cast_id, eq_natCast]
state_before: S : Type u
inst✝ : Semiring S
n k : ℕ
⊢ ↑(eval k (pochhammer ℕ n)) = eval (↑k) (pochhammer S n)
Theorem: Int.div_eq_ediv_of_dvd
File: Std/Data/Int/DivMod.lean

tactic: if b0 : b = 0 then simp [b0]
else rw [Int.div_eq_iff_eq_mul_left b0 h, ← Int.ediv_eq_iff_eq_mul_left b0 h]
state_before: a b : Int
h : b ∣ a
⊢ div a b = a / b

tactic: simp [b0]
state_before: a b : Int
h : b ∣ a
b0 : b = 0
⊢ div a b = a / b

tactic: rw [Int.div_eq_iff_eq_mul_left b0 h, ← Int.ediv_eq_iff_eq_mul_left b0 h]
state_before: a b : Int
h : b ∣ a
b0 : ¬b = 0
⊢ div a b = a / b
Theorem: PiNat.cylinder_eq_pi
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: ext y
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
⊢ cylinder x n = Set.pi ↑(Finset.range n) fun i => {x i}

tactic: simp [cylinder]
state_before: case h
E : ℕ → Type u_1
x : (n : ℕ) → E n
n : ℕ
y : (n : ℕ) → E n
⊢ y ∈ cylinder x n ↔ y ∈ Set.pi ↑(Finset.range n) fun i => {x i}
Theorem: Pmf.toOuterMeasure_apply_eq_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: rw [toOuterMeasure_apply, ENNReal.tsum_eq_zero]
state_before: α : Type u_1
β : Type ?u.25862
γ : Type ?u.25865
p : Pmf α
s t : Set α
⊢ ↑(toOuterMeasure p) s = 0 ↔ Disjoint (support p) s

tactic: exact Function.funext_iff.symm.trans Set.indicator_eq_zero'
state_before: α : Type u_1
β : Type ?u.25862
γ : Type ?u.25865
p : Pmf α
s t : Set α
⊢ (∀ (i : α), Set.indicator s (↑p) i = 0) ↔ Disjoint (support p) s
Theorem: Int.cast_le
File: Mathlib/Data/Int/Cast/Lemmas.lean

tactic: rw [← sub_nonneg, ← cast_sub, cast_nonneg, sub_nonneg]
state_before: F : Type ?u.15849
ι : Type ?u.15852
α : Type u_1
β : Type ?u.15858
inst✝¹ : OrderedRing α
inst✝ : Nontrivial α
m n : ℤ
⊢ ↑m ≤ ↑n ↔ m ≤ n
Theorem: Finsupp.update_eq_single_add_erase
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext j
state_before: α : Type u_1
β : Type ?u.295412
γ : Type ?u.295415
ι : Type ?u.295418
M : Type u_2
M' : Type ?u.295424
N : Type ?u.295427
P : Type ?u.295430
G : Type ?u.295433
H : Type ?u.295436
R : Type ?u.295439
S : Type ?u.295442
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
⊢ update f a b = single a b + erase a f

tactic: rcases eq_or_ne a j with (rfl | h)
state_before: case h
α : Type u_1
β : Type ?u.295412
γ : Type ?u.295415
ι : Type ?u.295418
M : Type u_2
M' : Type ?u.295424
N : Type ?u.295427
P : Type ?u.295430
G : Type ?u.295433
H : Type ?u.295436
R : Type ?u.295439
S : Type ?u.295442
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
j : α
⊢ ↑(update f a b) j = ↑(single a b + erase a f) j

tactic: simp
state_before: case h.inl
α : Type u_1
β : Type ?u.295412
γ : Type ?u.295415
ι : Type ?u.295418
M : Type u_2
M' : Type ?u.295424
N : Type ?u.295427
P : Type ?u.295430
G : Type ?u.295433
H : Type ?u.295436
R : Type ?u.295439
S : Type ?u.295442
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
⊢ ↑(update f a b) a = ↑(single a b + erase a f) a

tactic: simp [Function.update_noteq h.symm, single_apply, h, erase_ne, h.symm]
state_before: case h.inr
α : Type u_1
β : Type ?u.295412
γ : Type ?u.295415
ι : Type ?u.295418
M : Type u_2
M' : Type ?u.295424
N : Type ?u.295427
P : Type ?u.295430
G : Type ?u.295433
H : Type ?u.295436
R : Type ?u.295439
S : Type ?u.295442
inst✝ : AddZeroClass M
f : α →₀ M
a : α
b : M
j : α
h : a ≠ j
⊢ ↑(update f a b) j = ↑(single a b + erase a f) j
Theorem: iSup₂_inf_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simp only [iSup_inf_eq]
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort u_1
inst✝ : Frame α
s t : Set α
a✝ b : α
f : (i : ι) → κ i → α
a : α
⊢ (⨆ (i : ι) (j : κ i), f i j) ⊓ a = ⨆ (i : ι) (j : κ i), f i j ⊓ a
Theorem: sdiff_symmDiff'
File: Mathlib/Order/SymmDiff.lean

tactic: rw [sdiff_symmDiff, sdiff_sup, sup_comm]
state_before: ι : Type ?u.61584
α : Type u_1
β : Type ?u.61590
π : ι → Type ?u.61595
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ c \ a ∆ b = c ⊓ a ⊓ b ⊔ c \ (a ⊔ b)
Theorem: tendstoUniformlyOn_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F✝ : ι → α → β
f✝ : α → β
s✝ s' : Set α
x : α
p✝ : Filter ι
p' : Filter α
g : ι → α
F : ι → α → β
f : α → β
p : Filter ι
s : Set α
⊢ TendstoUniformlyOn F f p s ↔ Tendsto (fun q => (f q.snd, F q.fst q.snd)) (p ×ˢ 𝓟 s) (𝓤 β)
Theorem: OrderIso.preimage_Iio
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
⊢ ↑e ⁻¹' Iio b = Iio (↑(symm e) b)

tactic: simp [← e.lt_iff_lt]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
b : β
x : α
⊢ x ∈ ↑e ⁻¹' Iio b ↔ x ∈ Iio (↑(symm e) b)
Theorem: Matrix.mul_inv_eq_iff_eq_mul_of_invertible
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← h, inv_mul_cancel_right_of_invertible]
state_before: l : Type ?u.235209
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A✝ B✝ A B C : Matrix n n α
inst✝ : Invertible A
h : B ⬝ A⁻¹ = C
⊢ B = C ⬝ A

tactic: rw [h, mul_inv_cancel_right_of_invertible]
state_before: l : Type ?u.235209
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A✝ B✝ A B C : Matrix n n α
inst✝ : Invertible A
h : B = C ⬝ A
⊢ B ⬝ A⁻¹ = C
Theorem: iInf_false
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.105197
β₂ : Type ?u.105200
γ : Type ?u.105203
ι : Sort ?u.105206
ι' : Sort ?u.105209
κ : ι → Sort ?u.105214
κ' : ι' → Sort ?u.105219
inst✝ : CompleteLattice α
f g s✝ t : ι → α
a b : α
s : False → α
⊢ iInf s = ⊤
Theorem: bernsteinApproximation.apply
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: simp [bernsteinApproximation]
state_before: n : ℕ
f : C(↑I, ℝ)
x : ↑I
⊢ ↑(bernsteinApproximation n f) x = ∑ k : Fin (n + 1), ↑f k/ₙ * ↑(bernstein n ↑k) x
Theorem: EuclideanGeometry.continuousAt_angle
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: let f : P × P × P → V × V := fun y => (y.1 -ᵥ y.2.1, y.2.2 -ᵥ y.2.1)
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
⊢ ContinuousAt (fun y => ∠ y.fst y.snd.fst y.snd.snd) x

tactic: have hf1 : (f x).1 ≠ 0 := by simp [hx12]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
f : P × P × P → V × V := fun y => (y.fst -ᵥ y.snd.fst, y.snd.snd -ᵥ y.snd.fst)
⊢ ContinuousAt (fun y => ∠ y.fst y.snd.fst y.snd.snd) x

tactic: have hf2 : (f x).2 ≠ 0 := by simp [hx32]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
f : P × P × P → V × V := fun y => (y.fst -ᵥ y.snd.fst, y.snd.snd -ᵥ y.snd.fst)
hf1 : (f x).fst ≠ 0
⊢ ContinuousAt (fun y => ∠ y.fst y.snd.fst y.snd.snd) x

tactic: exact (InnerProductGeometry.continuousAt_angle hf1 hf2).comp
  ((continuous_fst.vsub continuous_snd.fst).prod_mk
    (continuous_snd.snd.vsub continuous_snd.fst)).continuousAt
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
f : P × P × P → V × V := fun y => (y.fst -ᵥ y.snd.fst, y.snd.snd -ᵥ y.snd.fst)
hf1 : (f x).fst ≠ 0
hf2 : (f x).snd ≠ 0
⊢ ContinuousAt (fun y => ∠ y.fst y.snd.fst y.snd.snd) x

tactic: simp [hx12]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
f : P × P × P → V × V := fun y => (y.fst -ᵥ y.snd.fst, y.snd.snd -ᵥ y.snd.fst)
⊢ (f x).fst ≠ 0

tactic: simp [hx32]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
x : P × P × P
hx12 : x.fst ≠ x.snd.fst
hx32 : x.snd.snd ≠ x.snd.fst
f : P × P × P → V × V := fun y => (y.fst -ᵥ y.snd.fst, y.snd.snd -ᵥ y.snd.fst)
hf1 : (f x).fst ≠ 0
⊢ (f x).snd ≠ 0
Theorem: max_one_div_max_inv_one_eq_self
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: rcases le_total a 1 with (h | h) <;> simp [h]
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ max a 1 / max a⁻¹ 1 = a
Theorem: Filter.frequently_imp_distrib
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [imp_iff_not_or, not_eventually, frequently_or_distrib]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.165345
ι : Sort x
f : Filter α
p q : α → Prop
⊢ (∃ᶠ (x : α) in f, p x → q x) ↔ (∀ᶠ (x : α) in f, p x) → ∃ᶠ (x : α) in f, q x
Theorem: Set.Countable.ae_not_mem
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simpa only [ae_iff, Classical.not_not] using h.measure_zero μ
state_before: α✝ : Type ?u.712897
β : Type ?u.712900
γ : Type ?u.712903
δ : Type ?u.712906
ι : Type ?u.712909
R : Type ?u.712912
R' : Type ?u.712915
m0 : MeasurableSpace α✝
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α✝
s✝ s' t : Set α✝
inst✝¹ : NoAtoms μ✝
α : Type u_1
m : MeasurableSpace α
s : Set α
h : Set.Countable s
μ : Measure α
inst✝ : NoAtoms μ
⊢ ∀ᵐ (x : α) ∂μ, ¬x ∈ s
Theorem: StieltjesFunction.measure_Ioc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: rw [StieltjesFunction.measure]
state_before: f : StieltjesFunction
a b : ℝ
⊢ ↑↑(StieltjesFunction.measure f) (Ioc a b) = ofReal (↑f b - ↑f a)

tactic: exact f.outer_Ioc a b
state_before: f : StieltjesFunction
a b : ℝ
⊢ ↑↑{ toOuterMeasure := StieltjesFunction.outer f,
            m_iUnion :=
              (_ :
                ∀ (_s : ℕ → Set ℝ),
                  (∀ (i : ℕ), MeasurableSet (_s i)) →
                    Pairwise (Disjoint on _s) →
                      ↑(StieltjesFunction.outer f) (⋃ (i : ℕ), _s i) = ∑' (i : ℕ), ↑(StieltjesFunction.outer f) (_s i)),
            trimmed := (_ : OuterMeasure.trim (StieltjesFunction.outer f) = StieltjesFunction.outer f) }
      (Ioc a b) =
    ofReal (↑f b - ↑f a)
Theorem: Polynomial.le_natTrailingDegree_mul
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: have hp : p ≠ 0 := fun hp => h (by rw [hp, zero_mul])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
⊢ natTrailingDegree p + natTrailingDegree q ≤ natTrailingDegree (p * q)

tactic: have hq : q ≠ 0 := fun hq => h (by rw [hq, mul_zero])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
⊢ natTrailingDegree p + natTrailingDegree q ≤ natTrailingDegree (p * q)

tactic: have : ∀ (p : R[X]), WithTop.some (natTrailingDegree p) = Nat.cast (natTrailingDegree p) :=
  fun p ↦ rfl
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ natTrailingDegree p + natTrailingDegree q ≤ natTrailingDegree (p * q)

tactic: rw [← WithTop.coe_le_coe, WithTop.coe_add, this p, this q, this (p * q),
  ← trailingDegree_eq_natTrailingDegree hp, ← trailingDegree_eq_natTrailingDegree hq,
  ← trailingDegree_eq_natTrailingDegree h]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
⊢ natTrailingDegree p + natTrailingDegree q ≤ natTrailingDegree (p * q)

tactic: exact le_trailingDegree_mul
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
this : ∀ (p : R[X]), ↑(natTrailingDegree p) = ↑(natTrailingDegree p)
⊢ trailingDegree p + trailingDegree q ≤ trailingDegree (p * q)

tactic: rw [hp, zero_mul]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p = 0
⊢ p * q = 0

tactic: rw [hq, mul_zero]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p * q ≠ 0
hp : p ≠ 0
hq : q = 0
⊢ p * q = 0
Theorem: Odd.add_dvd_pow_add_pow
File: Mathlib/Algebra/GeomSum.lean

tactic: have h₁ := geom_sum₂_mul x (-y) n
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
⊢ x + y ∣ x ^ n + y ^ n

tactic: rw [Odd.neg_pow h y, sub_neg_eq_add, sub_neg_eq_add] at h₁
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i in range n, x ^ i * (-y) ^ (n - 1 - i)) * (x - -y) = x ^ n - (-y) ^ n
⊢ x + y ∣ x ^ n + y ^ n

tactic: exact Dvd.intro_left _ h₁
state_before: α : Type u
inst✝ : CommRing α
x y : α
n : ℕ
h : Odd n
h₁ : (∑ i in range n, x ^ i * (-y) ^ (n - 1 - i)) * (x + y) = x ^ n + y ^ n
⊢ x + y ∣ x ^ n + y ^ n
Theorem: Mathlib.Tactic.Ring.mul_pp_pf_overlap
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea eb e : ℕ
a₂ b₂ c x : R
x✝¹ : ea + eb = e
x✝ : a₂ * b₂ = c
⊢ x ^ ea * a₂ * (x ^ eb * b₂) = x ^ e * c

tactic: simp [pow_add, mul_mul_mul_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
ea eb : ℕ
a₂ b₂ x : R
⊢ x ^ ea * a₂ * (x ^ eb * b₂) = x ^ (ea + eb) * (a₂ * b₂)
Theorem: FirstOrder.Language.Substructure.fg_iff_structure_fg
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [Structure.fg_def]
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
⊢ FG S ↔ Structure.FG L { x // x ∈ S }

tactic: refine' ⟨fun h => FG.of_map_embedding S.subtype _, fun h => _⟩
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
⊢ FG S ↔ FG ⊤

tactic: rw [← Hom.range_eq_map, range_subtype]
state_before: case refine'_1
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : FG S
⊢ FG (map (Embedding.toHom (subtype S)) ⊤)

tactic: exact h
state_before: case refine'_1
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : FG S
⊢ FG S

tactic: have h := h.map S.subtype.toHom
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h : FG ⊤
⊢ FG S

tactic: rw [← Hom.range_eq_map, range_subtype] at h
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h✝ : FG ⊤
h : FG (map (Embedding.toHom (subtype S)) ⊤)
⊢ FG S

tactic: exact h
state_before: case refine'_2
L : Language
M : Type u_3
inst✝ : Structure L M
S : Substructure L M
h✝ : FG ⊤
h : FG S
⊢ FG S
Theorem: Matrix.det_nonsing_inv_mul_det
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← det_mul, A.nonsing_inv_mul h, det_one]
state_before: l : Type ?u.240416
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ det A⁻¹ * det A = 1
Theorem: Submodule.span_singleton_eq_top_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [eq_top_iff, le_span_singleton_iff]
state_before: R : Type u_2
R₂ : Type ?u.123041
K : Type ?u.123044
M : Type u_1
M₂ : Type ?u.123050
V : Type ?u.123053
S : Type ?u.123056
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x : M
⊢ span R {x} = ⊤ ↔ ∀ (v : M), ∃ r, r • x = v

tactic: tauto
state_before: R : Type u_2
R₂ : Type ?u.123041
K : Type ?u.123044
M : Type u_1
M₂ : Type ?u.123050
V : Type ?u.123053
S : Type ?u.123056
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x : M
⊢ (∀ (v : M), v ∈ ⊤ → ∃ r, r • x = v) ↔ ∀ (v : M), ∃ r, r • x = v
Theorem: Cardinal.mk_multiset_of_countable
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp
state_before: α : Type u
inst✝¹ : Countable α
inst✝ : Nonempty α
⊢ (#α →₀ ℕ) = ℵ₀
Theorem: LinearMap.adjoint_comp
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: ext v
state_before: 𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
⊢ ↑adjoint (comp A B) = comp (↑adjoint B) (↑adjoint A)

tactic: refine' ext_inner_left 𝕜 fun w => _
state_before: case h
𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
⊢ ↑(↑adjoint (comp A B)) v = ↑(comp (↑adjoint B) (↑adjoint A)) v

tactic: simp only [adjoint_inner_right, LinearMap.coe_comp, Function.comp_apply]
state_before: case h
𝕜 : Type u_1
E : Type u_4
F : Type u_2
G : Type u_3
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : F →ₗ[𝕜] G
B : E →ₗ[𝕜] F
v : G
w : (fun x => E) v
⊢ inner w (↑(↑adjoint (comp A B)) v) = inner w (↑(comp (↑adjoint B) (↑adjoint A)) v)
Theorem: MeasureTheory.measure_union_eq_top_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp only [← lt_top_iff_ne_top, ← Ne.def, not_or, measure_union_lt_top_iff]
state_before: α : Type u_1
β : Type ?u.35027
γ : Type ?u.35030
δ : Type ?u.35033
ι : Type ?u.35036
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ ¬↑↑μ (s ∪ t) = ⊤ ↔ ¬(↑↑μ s = ⊤ ∨ ↑↑μ t = ⊤)
Theorem: ContinuousLinearMap.sSup_closed_unit_ball_eq_norm
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simpa only [NNReal.coe_sSup, Set.image_image] using
  NNReal.coe_eq.2 f.sSup_closed_unit_ball_eq_nnnorm
state_before: 𝕜✝ : Type ?u.834622
𝕜₂✝ : Type ?u.834625
𝕜₃ : Type ?u.834628
E✝ : Type ?u.834631
Eₗ : Type ?u.834634
F✝ : Type ?u.834637
Fₗ : Type ?u.834640
G : Type ?u.834643
Gₗ : Type ?u.834646
𝓕 : Type ?u.834649
inst✝²³ : SeminormedAddCommGroup E✝
inst✝²² : SeminormedAddCommGroup Eₗ
inst✝²¹ : SeminormedAddCommGroup F✝
inst✝²⁰ : SeminormedAddCommGroup Fₗ
inst✝¹⁹ : SeminormedAddCommGroup G
inst✝¹⁸ : SeminormedAddCommGroup Gₗ
inst✝¹⁷ : NontriviallyNormedField 𝕜✝
inst✝¹⁶ : NontriviallyNormedField 𝕜₂✝
inst✝¹⁵ : NontriviallyNormedField 𝕜₃
inst✝¹⁴ : NormedSpace 𝕜✝ E✝
inst✝¹³ : NormedSpace 𝕜✝ Eₗ
inst✝¹² : NormedSpace 𝕜₂✝ F✝
inst✝¹¹ : NormedSpace 𝕜✝ Fₗ
inst✝¹⁰ : NormedSpace 𝕜₃ G
inst✝⁹ : NormedSpace 𝕜✝ Gₗ
σ₁₂✝ : 𝕜✝ →+* 𝕜₂✝
σ₂₃ : 𝕜₂✝ →+* 𝕜₃
σ₁₃ : 𝕜✝ →+* 𝕜₃
inst✝⁸ : RingHomCompTriple σ₁₂✝ σ₂₃ σ₁₃
inst✝⁷ : RingHomIsometric σ₁₂✝
𝕜 : Type u_1
𝕜₂ : Type u_2
E : Type u_3
F : Type u_4
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SeminormedAddCommGroup F
inst✝⁴ : DenselyNormedField 𝕜
inst✝³ : NontriviallyNormedField 𝕜₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜₂ F
inst✝ : RingHomIsometric σ₁₂
f : E →SL[σ₁₂] F
⊢ sSup ((fun x => ‖↑f x‖) '' closedBall 0 1) = ‖f‖
Theorem: MeasureTheory.Integrable.smul_of_top_left
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hφ ⊢
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.1099822
δ : Type ?u.1099825
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hφ : Integrable φ
hf : Memℒp f ⊤
⊢ Integrable (φ • f)

tactic: exact Memℒp.smul_of_top_left hf hφ
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.1099822
δ : Type ?u.1099825
m : MeasurableSpace α
μ ν : Measure α
inst✝⁵ : MeasurableSpace δ
inst✝⁴ : NormedAddCommGroup β
inst✝³ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 β
inst✝ : BoundedSMul 𝕜 β
f : α → β
φ : α → 𝕜
hφ : Memℒp φ 1
hf : Memℒp f ⊤
⊢ Memℒp (φ • f) 1
Theorem: trop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: convert Multiset.trop_sum (s.val.map f)
state_before: R : Type u_1
S : Type u_2
inst✝ : AddCommMonoid R
s : Finset S
f : S → R
⊢ trop (∑ i in s, f i) = ∏ i in s, trop (f i)

tactic: simp only [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝ : AddCommMonoid R
s : Finset S
f : S → R
⊢ ∏ i in s, trop (f i) = Multiset.prod (Multiset.map trop (Multiset.map f s.val))

tactic: rfl
state_before: case h.e'_3
R : Type u_1
S : Type u_2
inst✝ : AddCommMonoid R
s : Finset S
f : S → R
⊢ ∏ i in s, trop (f i) = Multiset.prod (Multiset.map (fun i => trop (f i)) s.val)