tasksource/leandojo huggingface dataset:
Theorem: Matrix.det_of_upperTriangular
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: haveI : DecidableEq R := Classical.decEq _
state_before: α : Type ?u.121034
β : Type ?u.121037
m : Type u_1
n : Type ?u.121043
o : Type ?u.121046
m' : α → Type ?u.121051
n' : α → Type ?u.121056
R : Type v
inst✝⁵ : CommRing R
M N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
h : BlockTriangular M id
⊢ det M = ∏ i : m, M i i

tactic: simp_rw [h.det, image_id, det_toSquareBlock_id]
state_before: α : Type ?u.121034
β : Type ?u.121037
m : Type u_1
n : Type ?u.121043
o : Type ?u.121046
m' : α → Type ?u.121051
n' : α → Type ?u.121056
R : Type v
inst✝⁵ : CommRing R
M N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
h : BlockTriangular M id
this : DecidableEq R
⊢ det M = ∏ i : m, M i i
Theorem: Real.sin_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin_add]
state_before: x y : ℝ
⊢ ↑(sin (x + y)) = ↑(sin x * cos y + cos x * sin y)
Theorem: Set.image_prod_mk_subset_prod_right
File: Mathlib/Data/Set/Prod.lean

tactic: rintro _ ⟨b, hb, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.84021
δ : Type ?u.84024
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ha : a ∈ s
⊢ Prod.mk a '' t ⊆ s ×ˢ t

tactic: exact ⟨ha, hb⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.84021
δ : Type ?u.84024
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : a ∈ s
b : β
hb : b ∈ t
⊢ (a, b) ∈ s ×ˢ t
Theorem: MulChar.one_apply_coe
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: classical exact dif_pos a.isUnit
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
a : Rˣ
⊢ ↑1 ↑a = 1

tactic: exact dif_pos a.isUnit
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
a : Rˣ
⊢ ↑1 ↑a = 1
Theorem: Polynomial.not_separable_zero
File: Mathlib/FieldTheory/Separable.lean

tactic: rintro ⟨x, y, h⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial R
⊢ ¬Separable 0

tactic: simp only [derivative_zero, mul_zero, add_zero, zero_ne_one] at h
state_before: case intro.intro
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial R
x y : R[X]
h : x * 0 + y * ↑derivative 0 = 1
⊢ False
Theorem: Localization.mk_mul
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [Localization.mul]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.76919
inst✝¹ : CommMonoid N
P : Type ?u.76925
inst✝ : CommMonoid P
a c : M
b d : { x // x ∈ S }
⊢ Localization.mul S (mk a b) (mk c d) = mk (a * c) (b * d)

tactic: rfl
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.76919
inst✝¹ : CommMonoid N
P : Type ?u.76925
inst✝ : CommMonoid P
a c : M
b d : { x // x ∈ S }
⊢ Mul.mul (mk a b) (mk c d) = mk (a * c) (b * d)
Theorem: MvPolynomial.map_eval₂Hom
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [← comp_eval₂Hom]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
p : MvPolynomial σ R
⊢ ↑φ (↑(eval₂Hom f g) p) = ↑(eval₂Hom (RingHom.comp φ f) fun i => ↑φ (g i)) p

tactic: rfl
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : R →+* S₁
g✝ : σ → S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₁
φ : S₁ →+* S₂
p : MvPolynomial σ R
⊢ ↑φ (↑(eval₂Hom f g) p) = ↑(RingHom.comp φ (eval₂Hom f fun i => g i)) p
Theorem: Asymptotics.isBigOWith_insert
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp_rw [IsBigOWith_def, nhdsWithin_insert, eventually_sup, eventually_pure, h, true_and_iff]
state_before: α : Type u_1
β : Type ?u.112779
E : Type u_2
F : Type u_3
G : Type ?u.112788
E' : Type ?u.112791
F' : Type ?u.112794
G' : Type ?u.112797
E'' : Type ?u.112800
F'' : Type ?u.112803
G'' : Type ?u.112806
R : Type ?u.112809
R' : Type ?u.112812
𝕜 : Type ?u.112815
𝕜' : Type ?u.112818
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedRing R'
inst✝² : NormedField 𝕜
inst✝¹ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g✝ : α → F
k : α → G
f' : α → E'
g'✝ : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝ : TopologicalSpace α
x : α
s : Set α
C : ℝ
g : α → E
g' : α → F
h : ‖g x‖ ≤ C * ‖g' x‖
⊢ IsBigOWith C (𝓝[insert x s] x) g g' ↔ IsBigOWith C (𝓝[s] x) g g'
Theorem: zpow_one_add₀
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: rw [zpow_add₀ h, zpow_one]
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
h : a ≠ 0
i : ℤ
⊢ a ^ (1 + i) = a * a ^ i
Theorem: IsCompact.closedBall_one_mul
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, hs.mul_closedBall_one hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ closedBall 1 δ * s = cthickening δ s
Theorem: Multiset.prod_hom_rel
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simp only [l.prod_hom_rel h₁ h₂, quot_mk_to_coe, coe_map, coe_prod]
state_before: ι : Type u_2
α : Type u_3
β : Type u_1
γ : Type ?u.53519
inst✝¹ : CommMonoid α
s✝ t : Multiset α
a : α
m : Multiset ι
f✝ g✝ : ι → α
inst✝ : CommMonoid β
s : Multiset ι
r : α → β → Prop
f : ι → α
g : ι → β
h₁ : r 1 1
h₂ : ∀ ⦃a : ι⦄ ⦃b : α⦄ ⦃c : β⦄, r b c → r (f a * b) (g a * c)
l : List ι
⊢ r (prod (map f (Quotient.mk (List.isSetoid ι) l))) (prod (map g (Quotient.mk (List.isSetoid ι) l)))
Theorem: PFunctor.M.Approx.P_mk
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: constructor
state_before: F : PFunctor
X : Type ?u.14033
f : X → Obj F X
x : Obj F (M F)
⊢ Agree (Approx.sMk x 0) (Approx.sMk x (succ 0))

tactic: constructor
state_before: F : PFunctor
X : Type ?u.14033
f : X → Obj F X
x : Obj F (M F)
n : ℕ
⊢ Agree (Approx.sMk x (succ n)) (Approx.sMk x (succ (succ n)))

tactic: introv
state_before: case a
F : PFunctor
X : Type ?u.14033
f : X → Obj F X
x : Obj F (M F)
n : ℕ
⊢ ∀ (i : B F x.fst), Agree (MIntl.approx (Sigma.snd x i) n) (MIntl.approx (Sigma.snd x i) (succ n))

tactic: apply (x.2 i).consistent
state_before: case a
F : PFunctor
X : Type ?u.14033
f : X → Obj F X
x : Obj F (M F)
n : ℕ
i : B F x.fst
⊢ Agree (MIntl.approx (Sigma.snd x i) n) (MIntl.approx (Sigma.snd x i) (succ n))
Theorem: Finset.exists_one_lt_of_prod_one_of_exists_ne_one'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: contrapose! h₁
state_before: ι : Type u_2
α : Type ?u.144930
β : Type ?u.144933
M : Type u_1
N : Type ?u.144939
G : Type ?u.144942
k : Type ?u.144945
R : Type ?u.144948
inst✝ : LinearOrderedCancelCommMonoid M
f✝ g : ι → M
s t : Finset ι
f : ι → M
h₁ : ∏ i in s, f i = 1
h₂ : ∃ i, i ∈ s ∧ f i ≠ 1
⊢ ∃ i, i ∈ s ∧ 1 < f i

tactic: obtain ⟨i, m, i_ne⟩ : ∃ i ∈ s, f i ≠ 1 := h₂
state_before: ι : Type u_2
α : Type ?u.144930
β : Type ?u.144933
M : Type u_1
N : Type ?u.144939
G : Type ?u.144942
k : Type ?u.144945
R : Type ?u.144948
inst✝ : LinearOrderedCancelCommMonoid M
f✝ g : ι → M
s t : Finset ι
f : ι → M
h₂ : ∃ i, i ∈ s ∧ f i ≠ 1
h₁ : ∀ (i : ι), i ∈ s → f i ≤ 1
⊢ ∏ i in s, f i ≠ 1

tactic: apply ne_of_lt
state_before: case intro.intro
ι : Type u_2
α : Type ?u.144930
β : Type ?u.144933
M : Type u_1
N : Type ?u.144939
G : Type ?u.144942
k : Type ?u.144945
R : Type ?u.144948
inst✝ : LinearOrderedCancelCommMonoid M
f✝ g : ι → M
s t : Finset ι
f : ι → M
h₁ : ∀ (i : ι), i ∈ s → f i ≤ 1
i : ι
m : i ∈ s
i_ne : f i ≠ 1
⊢ ∏ i in s, f i ≠ 1

tactic: calc
  (∏ j in s, f j) < ∏ j in s, 1 := prod_lt_prod' h₁ ⟨i, m, (h₁ i m).lt_of_ne i_ne⟩
  _ = 1 := prod_const_one
state_before: case intro.intro.h
ι : Type u_2
α : Type ?u.144930
β : Type ?u.144933
M : Type u_1
N : Type ?u.144939
G : Type ?u.144942
k : Type ?u.144945
R : Type ?u.144948
inst✝ : LinearOrderedCancelCommMonoid M
f✝ g : ι → M
s t : Finset ι
f : ι → M
h₁ : ∀ (i : ι), i ∈ s → f i ≤ 1
i : ι
m : i ∈ s
i_ne : f i ≠ 1
⊢ ∏ i in s, f i < 1
Theorem: GroupCat.SurjectiveOfEpiAuxs.mul_smul
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: change fromCoset _ = fromCoset _
state_before: A B : GroupCat
f : A ⟶ B
b b' : ↑B
x : X'
y : ↑(Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier))
⊢ (b * b') • fromCoset y = b • b' • fromCoset y

tactic: simp only [leftCoset_assoc]
state_before: A B : GroupCat
f : A ⟶ B
b b' : ↑B
x : X'
y : ↑(Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier))
⊢ fromCoset
      { val := b * b' *l ↑y,
        property :=
          (_ :
            b * b' *l ↑y ∈
              Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) } =
    fromCoset
      {
        val :=
          b *l
            ↑{ val := b' *l ↑y,
                property :=
                  (_ :
                    b' *l ↑y ∈
                      Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) },
        property :=
          (_ :
            b *l
                ↑{ val := b' *l ↑y,
                    property :=
                      (_ :
                        b' *l ↑y ∈
                          Set.range
                            (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) } ∈
              Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) }
Theorem: ENNReal.rpow_lt_rpow_of_exponent_gt
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: lift x to ℝ≥0 using ne_of_lt (lt_of_lt_of_le hx1 le_top)
state_before: x : ℝ≥0∞
y z : ℝ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ x ^ y < x ^ z

tactic: simp only [coe_lt_one_iff, coe_pos] at hx0 hx1
state_before: case intro
y z : ℝ
hyz : z < y
x : ℝ≥0
hx0 : 0 < ↑x
hx1 : ↑x < 1
⊢ ↑x ^ y < ↑x ^ z

tactic: simp [coe_rpow_of_ne_zero (ne_of_gt hx0), NNReal.rpow_lt_rpow_of_exponent_gt hx0 hx1 hyz]
state_before: case intro
y z : ℝ
hyz : z < y
x : ℝ≥0
hx0 : 0 < x
hx1 : x < 1
⊢ ↑x ^ y < ↑x ^ z
Theorem: MeasureTheory.OuterMeasure.restrict_mono
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [restrict_apply]
state_before: α : Type u_1
β : Type ?u.103430
R : Type ?u.103433
R' : Type ?u.103436
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
s t : Set α
h : s ⊆ t
m m' : OuterMeasure α
hm : m ≤ m'
u : Set α
⊢ ↑(↑(restrict s) m) u ≤ ↑(↑(restrict t) m') u

tactic: exact (hm _).trans (m'.mono <| inter_subset_inter_right _ h)
state_before: α : Type u_1
β : Type ?u.103430
R : Type ?u.103433
R' : Type ?u.103436
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
s t : Set α
h : s ⊆ t
m m' : OuterMeasure α
hm : m ≤ m'
u : Set α
⊢ ↑m (u ∩ s) ≤ ↑m' (u ∩ t)
Theorem: sup_inf_right
File: Mathlib/Order/Lattice.lean

tactic: simp only [sup_inf_left, fun y : α => @sup_comm α _ y x, eq_self_iff_true]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ y ⊓ z ⊔ x = (y ⊔ x) ⊓ (z ⊔ x)
Theorem: Finset.insert_inter_of_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: have : x = a ∨ x ∈ s₂ ↔ x ∈ s₂ := or_iff_right_of_imp <| by rintro rfl; exact h
state_before: α : Type u_1
β : Type ?u.184340
γ : Type ?u.184343
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)

tactic: simp only [mem_inter, mem_insert, or_and_left, this]
state_before: α : Type u_1
β : Type ?u.184340
γ : Type ?u.184343
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
this : x = a ∨ x ∈ s₂ ↔ x ∈ s₂
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)

tactic: rintro rfl
state_before: α : Type u_1
β : Type ?u.184340
γ : Type ?u.184343
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
⊢ x = a → x ∈ s₂

tactic: exact h
state_before: α : Type u_1
β : Type ?u.184340
γ : Type ?u.184343
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x : α
h : x ∈ s₂
⊢ x ∈ s₂
Theorem: Set.Intersecting.isUpperSet
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: rintro a b hab ha
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a b c : α
hs : Intersecting s
h : ∀ (t : Set α), Intersecting t → s ⊆ t → s = t
⊢ IsUpperSet s

tactic: rw [h (Insert.insert b s) _ (subset_insert _ _)]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
hs : Intersecting s
h : ∀ (t : Set α), Intersecting t → s ⊆ t → s = t
a b : α
hab : a ≤ b
ha : a ∈ s
⊢ b ∈ s

tactic: exact
  hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
hs : Intersecting s
h : ∀ (t : Set α), Intersecting t → s ⊆ t → s = t
a b : α
hab : a ≤ b
ha : a ∈ s
⊢ Intersecting (Insert.insert b s)

tactic: exact mem_insert _ _
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s t : Set α
a✝ b✝ c : α
hs : Intersecting s
h : ∀ (t : Set α), Intersecting t → s ⊆ t → s = t
a b : α
hab : a ≤ b
ha : a ∈ s
⊢ b ∈ Insert.insert b s
Theorem: Int.modEq_zero_iff
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [ModEq, emod_zero, emod_zero]
state_before: m n a b c d : ℤ
⊢ a ≡ b [ZMOD 0] ↔ a = b
Theorem: Nat.one_lt_two_pow'
File: Mathlib/Data/Nat/Pow.lean

tactic: decide
state_before: n : ℕ
⊢ 1 < 2
Theorem: isOpen_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: rw [interior_eq_nhds]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ s ⊆ interior s ↔ ∀ (a : α), a ∈ s → 𝓝 a ≤ 𝓟 s

tactic: rfl
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ s ⊆ {a | 𝓝 a ≤ 𝓟 s} ↔ ∀ (a : α), a ∈ s → 𝓝 a ≤ 𝓟 s
Theorem: padicValNat.prime_pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat.pow _ (@Fact.out p.Prime).ne_zero, padicValNat_self, mul_one]
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ padicValNat p (p ^ n) = n
Theorem: inseparable_prod
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [Inseparable, nhds_prod_eq, prod_inj]
state_before: X : Type u_2
Y : Type u_1
Z : Type ?u.33260
α : Type ?u.33263
ι : Type ?u.33266
π : ι → Type ?u.33271
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f : X → Y
x₁ x₂ : X
y₁ y₂ : Y
⊢ ((x₁, y₁) ~ᵢ (x₂, y₂)) ↔ (x₁ ~ᵢ x₂) ∧ (y₁ ~ᵢ y₂)
Theorem: Int.mod_self
File: Std/Data/Int/DivMod.lean

tactic: have := mul_mod_left 1 a
state_before: a : Int
⊢ mod a a = 0

tactic: rwa [Int.one_mul] at this
state_before: a : Int
this : mod (1 * a) a = 0
⊢ mod a a = 0
Theorem: Stirling.log_stirlingSeq'_antitone
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: positivity
state_before: n m : ℕ
⊢ 0 ≤ 1 / (2 * ↑(succ m) + 1) * ((1 / (2 * ↑(succ n) + 1)) ^ 2) ^ succ m
Theorem: MeasureTheory.setToFun_congr_measure_of_add_right
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: refine' setToFun_congr_measure_of_integrable 1 one_ne_top _ hT_add hT f hf
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1657893
G : Type ?u.1657896
𝕜 : Type ?u.1657899
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : Integrable f
⊢ setToFun (μ + μ') T hT_add f = setToFun μ T hT f

tactic: rw [one_smul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1657893
G : Type ?u.1657896
𝕜 : Type ?u.1657899
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : Integrable f
⊢ μ ≤ 1 • (μ + μ')

tactic: nth_rw 1 [← add_zero μ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1657893
G : Type ?u.1657896
𝕜 : Type ?u.1657899
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : Integrable f
⊢ μ ≤ μ + μ'

tactic: exact add_le_add le_rfl bot_le
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1657893
G : Type ?u.1657896
𝕜 : Type ?u.1657899
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ T C
f : α → E
hf : Integrable f
⊢ μ + 0 ≤ μ + μ'
Theorem: List.isRotated_append
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
l l' : List α
⊢ rotate (l ++ l') (length l) = l' ++ l
Theorem: Int.ceil_sub_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [eq_sub_iff_add_eq, ← ceil_add_one, sub_add_cancel]
state_before: F : Type ?u.216039
α : Type u_1
β : Type ?u.216045
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a - 1⌉ = ⌈a⌉ - 1
Theorem: Int.eq_of_mul_eq_mul_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.mul_sub, this]
state_before: a b c : Int
ha : a ≠ 0
h : a * b = a * c
this : a * b - a * c = 0
⊢ a * (b - c) = 0
Theorem: InfTopHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.126824
ι : Type ?u.126827
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.126839
inst✝⁷ : Inf α
inst✝⁶ : Top α
inst✝⁵ : Inf β
inst✝⁴ : Top β
inst✝³ : Inf γ
inst✝² : Top γ
inst✝¹ : Inf δ
inst✝ : Top δ
g : InfTopHom β γ
f₁ f₂ : InfTopHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: CategoryTheory.transferNatTransSelf_symm_id
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

tactic: rw [Equiv.symm_apply_eq]
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
⊢ ↑(transferNatTransSelf adj₁ adj₁).symm (𝟙 R₁) = 𝟙 L₁

tactic: simp
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category C
inst✝ : Category D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
⊢ 𝟙 R₁ = ↑(transferNatTransSelf adj₁ adj₁) (𝟙 L₁)
Theorem: mul_inv_lt_of_lt_mul₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: contrapose! h
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : x < y * z
⊢ x * z⁻¹ < y

tactic: simpa only [inv_inv] using mul_inv_le_of_le_mul h
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : y ≤ x * z⁻¹
⊢ y * z ≤ x
Theorem: Finset.coe_disjiUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [Set.ext_iff, mem_disjiUnion, Set.mem_iUnion, iff_self_iff, mem_coe, imp_true_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.484460
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
h : Set.PairwiseDisjoint (↑s) t
⊢ ↑(disjiUnion s t h) = ⋃ (x : α) (_ : x ∈ ↑s), ↑(t x)
Theorem: MeasureTheory.Integrable.of_measure_le_smul
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf⊢
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.837801
δ : Type ?u.837804
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → β
hf : Integrable f
⊢ Integrable f

tactic: exact hf.of_measure_le_smul c hc hμ'_le
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.837801
δ : Type ?u.837804
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
μ' : Measure α
c : ℝ≥0∞
hc : c ≠ ⊤
hμ'_le : μ' ≤ c • μ
f : α → β
hf : Memℒp f 1
⊢ Memℒp f 1
Theorem: CategoryTheory.leftAdjointMate_comp_evaluation
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: apply_fun tensorLeftHomEquiv _ (ᘁX) X _
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (𝟙 X ⊗ ᘁf) ≫ ε_ (ᘁX) X = (f ⊗ 𝟙 ᘁY) ≫ ε_ (ᘁY) Y

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ ↑(tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) ((𝟙 X ⊗ ᘁf) ≫ ε_ (ᘁX) X) =
    ↑(tensorLeftHomEquiv (ᘁY) (ᘁX) X (𝟙_ C)) ((f ⊗ 𝟙 ᘁY) ≫ ε_ (ᘁY) Y)
Theorem: Real.toNNReal_div'
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [div_eq_inv_mul, div_eq_inv_mul, Real.toNNReal_mul (inv_nonneg.2 hy), Real.toNNReal_inv]
state_before: x y : ℝ
hy : 0 ≤ y
⊢ toNNReal (x / y) = toNNReal x / toNNReal y