tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.IsFundamentalDomain.sum_restrict_of_ac
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: rw [← restrict_iUnion_ae (h.aedisjoint.mono fun i j h => hν h) fun g =>
    (h.nullMeasurableSet_smul g).mono_ac hν,
  restrict_congr_set (hν h.iUnion_smul_ae_eq), restrict_univ]
state_before: G : Type u_1
H : Type ?u.157160
α : Type u_2
β : Type ?u.157166
E : Type ?u.157169
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
h : IsFundamentalDomain G s
hν : ν ≪ μ
⊢ (sum fun g => Measure.restrict ν (g • s)) = ν
Theorem: HasFTaylorSeriesUpToOn.add
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: convert HasFTaylorSeriesUpToOn.continuousLinearMap_comp
  (ContinuousLinearMap.fst 𝕜 F F + .snd 𝕜 F F) (hf.prod hg)
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.1668378
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p q : E → FormalMultilinearSeries 𝕜 E F
g : E → F
hf : HasFTaylorSeriesUpToOn n f p s
hg : HasFTaylorSeriesUpToOn n g q s
⊢ HasFTaylorSeriesUpToOn n (f + g) (p + q) s
Theorem: FirstOrder.Language.Formula.realize_rel₁
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Relations.formula₁, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.236870
P : Type ?u.236873
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
⊢ Realize (Relations.formula₁ R t) v ↔ RelMap R ![Term.realize v t]

tactic: refine' congr rfl (funext fun _ => _)
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.236870
P : Type ?u.236873
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
⊢ (RelMap R fun i => Term.realize v (Matrix.vecCons t ![] i)) = RelMap R ![Term.realize v t]

tactic: simp only [Matrix.cons_val_fin_one]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.236870
P : Type ?u.236873
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 1
t : Term L α
x✝ : Fin 1
⊢ Term.realize v (Matrix.vecCons t ![] x✝) = Matrix.vecCons (Term.realize v t) ![] x✝
Theorem: ContinuousMap.tendstoLocallyUniformly_of_tendsto
File: Mathlib/Topology/UniformSpace/CompactConvergence.lean

tactic: rw [tendsto_iff_forall_compact_tendstoUniformlyOn] at h
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
hα : ∀ (x : α), ∃ n, IsCompact n ∧ n ∈ 𝓝 x
h : Tendsto F p (𝓝 f)
⊢ TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p

tactic: intro V hV x
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
hα : ∀ (x : α), ∃ n, IsCompact n ∧ n ∈ 𝓝 x
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K
⊢ TendstoLocallyUniformly (fun i a => ↑(F i) a) (↑f) p

tactic: obtain ⟨n, hn₁, hn₂⟩ := hα x
state_before: α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
hα : ∀ (x : α), ∃ n, IsCompact n ∧ n ∈ 𝓝 x
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
⊢ ∃ t, t ∈ 𝓝 x ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (↑f y, (fun i a => ↑(F i) a) n y) ∈ V

tactic: exact ⟨n, hn₂, h n hn₁ V hV⟩
state_before: case intro.intro
α : Type u₁
β : Type u₂
inst✝¹ : TopologicalSpace α
inst✝ : UniformSpace β
K : Set α
V✝ : Set (β × β)
f : C(α, β)
ι : Type u₃
p : Filter ι
F : ι → C(α, β)
hα : ∀ (x : α), ∃ n, IsCompact n ∧ n ∈ 𝓝 x
h : ∀ (K : Set α), IsCompact K → TendstoUniformlyOn (fun i a => ↑(F i) a) (↑f) p K
V : Set (β × β)
hV : V ∈ 𝓤 β
x : α
n : Set α
hn₁ : IsCompact n
hn₂ : n ∈ 𝓝 x
⊢ ∃ t, t ∈ 𝓝 x ∧ ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ t → (↑f y, (fun i a => ↑(F i) a) n y) ∈ V
Theorem: CategoryTheory.Limits.inl_pushoutAssoc_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [Iso.comp_inv_eq, Category.assoc, inl_inl_pushoutAssoc_hom]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inl ≫ pushout.inl
Theorem: Nat.chineseRemainder'_lt_lcm
File: Mathlib/Data/Nat/ModEq.lean

tactic: dsimp only [chineseRemainder']
state_before: m n a b c d : ℕ
h : a ≡ b [MOD gcd n m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ↑(chineseRemainder' h) < lcm n m

tactic: rw [dif_neg hn, dif_neg hm, Subtype.coe_mk, xgcd_val, ← Int.toNat_coe_nat (lcm n m)]
state_before: m n a b c d : ℕ
h : a ≡ b [MOD gcd n m]
hn : n ≠ 0
hm : m ≠ 0
⊢ ↑(if hn : n = 0 then { val := a, property := (_ : a ≡ a [MOD n] ∧ a ≡ b [MOD m]) }
      else
        if hm : m = 0 then { val := b, property := (_ : b ≡ a [MOD n] ∧ b ≡ b [MOD m]) }
        else
          { val := Int.toNat ((↑n * (xgcd n m).fst * ↑b + ↑m * (xgcd n m).snd * ↑a) / ↑(gcd n m) % ↑(lcm n m)),
            property :=
              (_ :
                (match xgcd n m with
                    | (c, d) => Int.toNat ((↑n * c * ↑b + ↑m * d * ↑a) / ↑(gcd n m) % ↑(lcm n m))) ≡
                    a [MOD n] ∧
                  (match xgcd n m with
                    | (c, d) => Int.toNat ((↑n * c * ↑b + ↑m * d * ↑a) / ↑(gcd n m) % ↑(lcm n m))) ≡
                    b [MOD m]) }) <
    lcm n m

tactic: have lcm_pos := Int.coe_nat_pos.mpr (Nat.pos_of_ne_zero (lcm_ne_zero hn hm))
state_before: m n a b c d : ℕ
h : a ≡ b [MOD gcd n m]
hn : n ≠ 0
hm : m ≠ 0
⊢ Int.toNat
      ((↑n * (gcdA n m, gcdB n m).fst * ↑b + ↑m * (gcdA n m, gcdB n m).snd * ↑a) / ↑(gcd n m) %
        ↑(Int.toNat ↑(lcm n m))) <
    Int.toNat ↑(lcm n m)

tactic: exact (Int.toNat_lt_toNat lcm_pos).mpr (Int.emod_lt_of_pos _ lcm_pos)
state_before: m n a b c d : ℕ
h : a ≡ b [MOD gcd n m]
hn : n ≠ 0
hm : m ≠ 0
lcm_pos : 0 < ↑(lcm n m)
⊢ Int.toNat
      ((↑n * (gcdA n m, gcdB n m).fst * ↑b + ↑m * (gcdA n m, gcdB n m).snd * ↑a) / ↑(gcd n m) %
        ↑(Int.toNat ↑(lcm n m))) <
    Int.toNat ↑(lcm n m)
Theorem: sq_sum_le_card_mul_sum_sq
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: simp_rw [sq]
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.19415
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
⊢ (∑ i in s, f i) ^ 2 ≤ ↑(card s) * ∑ i in s, f i ^ 2

tactic: exact (monovaryOn_self _ _).sum_mul_sum_le_card_mul_sum
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.19415
inst✝ : LinearOrderedRing α
s : Finset ι
σ : Perm ι
f g : ι → α
⊢ (∑ i in s, f i) * ∑ i in s, f i ≤ ↑(card s) * ∑ x in s, f x * f x
Theorem: Colex.hom_fin_lt_iff
File: Mathlib/Combinatorics/Colex.lean

tactic: refine' Colex.hom_lt_iff _ _ _
state_before: α : Type ?u.6170
n : ℕ
A B : Finset (Fin n)
⊢ toColex (image (fun i => ↑i) A) < toColex (image (fun i => ↑i) B) ↔ toColex A < toColex B

tactic: exact (fun x y k => k)
state_before: α : Type ?u.6170
n : ℕ
A B : Finset (Fin n)
⊢ StrictMono fun i => ↑i
Theorem: ENNReal.nhds_top
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [lt_top_iff_ne_top, Ioi]
state_before: α : Type ?u.30563
β : Type ?u.30566
γ : Type ?u.30569
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ (⨅ (l : ℝ≥0∞) (_ : l < ⊤), 𝓟 (Ioi l)) = ⨅ (a : ℝ≥0∞) (_ : a ≠ ⊤), 𝓟 (Ioi a)
Theorem: Nat.mul_div_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm, mul_div_right _ H]
state_before: m n : Nat
H : 0 < n
⊢ m * n / n = m
Theorem: toIcoDiv_eq_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoDiv_sub_eq_toIcoDiv_add, zero_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b = toIcoDiv hp 0 (b - a)
Theorem: MeasureTheory.VectorMeasure.le_iff'
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: refine' ⟨fun h i => _, fun h i _ => h i⟩
state_before: α : Type u_1
β : Type ?u.540108
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
⊢ v ≤ w ↔ ∀ (i : Set α), ↑v i ≤ ↑w i

tactic: by_cases hi : MeasurableSet i
state_before: α : Type u_1
β : Type ?u.540108
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
⊢ ↑v i ≤ ↑w i

tactic: exact h i hi
state_before: case pos
α : Type u_1
β : Type ?u.540108
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : MeasurableSet i
⊢ ↑v i ≤ ↑w i

tactic: rw [v.not_measurable hi, w.not_measurable hi]
state_before: case neg
α : Type u_1
β : Type ?u.540108
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
u v w : VectorMeasure α M
h : v ≤ w
i : Set α
hi : ¬MeasurableSet i
⊢ ↑v i ≤ ↑w i
Theorem: padicValRat.finite_int_prime_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [finite_int_iff, hp.1.ne_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
⊢ multiplicity.Finite (↑p) a ↔ a ≠ 0
Theorem: Finset.Set.Sized.upShadow
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: intro A h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
⊢ Set.Sized (r + 1) ↑((∂⁺ ) 𝒜)

tactic: obtain ⟨A, hA, i, hi, rfl⟩ := mem_upShadow_iff.1 h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
h : A ∈ ↑((∂⁺ ) 𝒜)
⊢ card A = r + 1

tactic: rw [card_insert_of_not_mem hi, h𝒜 hA]
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
hA : A ∈ 𝒜
i : α
hi : ¬i ∈ A
h : insert i A ∈ ↑((∂⁺ ) 𝒜)
⊢ card (insert i A) = r + 1
Theorem: Pmf.toMeasure_apply_eq_of_inter_support_eq
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: simpa only [p.toMeasure_apply_eq_toOuterMeasure_apply, hs, ht] using
  toOuterMeasure_apply_eq_of_inter_support_eq p h
state_before: α : Type u_1
β : Type ?u.85531
γ : Type ?u.85534
inst✝ : MeasurableSpace α
p : Pmf α
s✝ t✝ s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : s ∩ support p = t ∩ support p
⊢ ↑↑(toMeasure p) s = ↑↑(toMeasure p) t
Theorem: Multiset.bind_add
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind, join]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.13310
δ : Type ?u.13313
a : α
s t : Multiset α
f g : α → Multiset β
⊢ (bind s fun a => f a + g a) = bind s f + bind s g
Theorem: List.get_append_right'
File: Std/Data/List/Lemmas.lean

tactic: rw [← get?_eq_get, ← get?_eq_get, get?_append_right h₁]
state_before: α : Type u_1
l₁ l₂ : List α
n : Nat
h₁ : length l₁ ≤ n
h₂ : n < length (l₁ ++ l₂)
⊢ some (get (l₁ ++ l₂) { val := n, isLt := h₂ }) =
    some (get l₂ { val := n - length l₁, isLt := (_ : n - length l₁ < length l₂) })
Theorem: Linarith.mul_nonpos
File: Mathlib/Tactic/Linarith/Lemmas.lean

tactic: simpa
state_before: α : Type u_1
inst✝ : OrderedRing α
a b : α
ha : a ≤ 0
hb : 0 < b
this : -b * a ≥ 0
⊢ b * a ≤ 0
Theorem: isIntegral_tower_bot_of_isIntegral
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rcases h with ⟨p, ⟨hp, hp'⟩⟩
state_before: R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.1449203
T : Type ?u.1449206
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
H : Function.Injective ↑(algebraMap A B)
x : A
h : IsIntegral R (↑(algebraMap A B) x)
⊢ IsIntegral R x

tactic: refine' ⟨p, ⟨hp, _⟩⟩
state_before: case intro.intro
R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.1449203
T : Type ?u.1449206
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
H : Function.Injective ↑(algebraMap A B)
x : A
p : R[X]
hp : Monic p
hp' : eval₂ (algebraMap R ((fun x => B) x)) (↑(algebraMap A B) x) p = 0
⊢ IsIntegral R x

tactic: rw [IsScalarTower.algebraMap_eq R A B, ← eval₂_map, eval₂_hom, ←
  RingHom.map_zero (algebraMap A B)] at hp'
state_before: case intro.intro
R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.1449203
T : Type ?u.1449206
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
H : Function.Injective ↑(algebraMap A B)
x : A
p : R[X]
hp : Monic p
hp' : eval₂ (algebraMap R ((fun x => B) x)) (↑(algebraMap A B) x) p = 0
⊢ eval₂ (algebraMap R A) x p = 0

tactic: rw [eval₂_eq_eval_map]
state_before: case intro.intro
R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.1449203
T : Type ?u.1449206
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
H : Function.Injective ↑(algebraMap A B)
x : A
p : R[X]
hp : Monic p
hp' : ↑(algebraMap A B) (eval x (Polynomial.map (algebraMap R A) p)) = ↑(algebraMap A B) 0
⊢ eval₂ (algebraMap R A) x p = 0

tactic: exact H hp'
state_before: case intro.intro
R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.1449203
T : Type ?u.1449206
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
H : Function.Injective ↑(algebraMap A B)
x : A
p : R[X]
hp : Monic p
hp' : ↑(algebraMap A B) (eval x (Polynomial.map (algebraMap R A) p)) = ↑(algebraMap A B) 0
⊢ eval x (Polynomial.map (algebraMap R A) p) = 0
Theorem: Complex.sinh_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sinh_add, sinh_neg, cosh_neg]
state_before: x y : ℂ
⊢ sinh (x - y) = sinh x * cosh y - cosh x * sinh y
Theorem: Quiver.eq_nil_of_length_zero
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: cases p <;> simp only [Nat.succ_ne_zero, length_cons] at hzero
state_before: U : Type u_1
inst✝ : Quiver U
u v : U
p : Path u v
hzero : length p = 0
⊢ Path.cast (_ : u = v) (_ : v = v) p = nil

tactic: rfl
state_before: case nil
U : Type u_1
inst✝ : Quiver U
u : U
hzero : length nil = 0
⊢ Path.cast (_ : u = u) (_ : u = u) nil = nil
Theorem: le_div_iff_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← neg_neg c, mul_neg, div_neg, le_neg, div_le_iff (neg_pos.2 hc), neg_mul]
state_before: ι : Type ?u.144887
α : Type u_1
β : Type ?u.144893
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ a ≤ b / c ↔ b ≤ a * c
Theorem: Finset.piecewise_compl
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.22254
γ : Type ?u.22257
inst✝³ : Fintype α
s✝ t : Finset α
inst✝² : DecidableEq α
s : Finset α
inst✝¹ : (i : α) → Decidable (i ∈ s)
inst✝ : (i : α) → Decidable (i ∈ sᶜ)
δ : α → Sort u_2
f g : (i : α) → δ i
⊢ piecewise (sᶜ) f g = piecewise s g f

tactic: simp [piecewise]
state_before: case h
α : Type u_1
β : Type ?u.22254
γ : Type ?u.22257
inst✝³ : Fintype α
s✝ t : Finset α
inst✝² : DecidableEq α
s : Finset α
inst✝¹ : (i : α) → Decidable (i ∈ s)
inst✝ : (i : α) → Decidable (i ∈ sᶜ)
δ : α → Sort u_2
f g : (i : α) → δ i
i : α
⊢ piecewise (sᶜ) f g i = piecewise s g f i
Theorem: Set.union_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.11513
δ : Type ?u.11516
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t

tactic: simp [or_and_right]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.11513
δ : Type ?u.11516
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ (s₁ ∪ s₂) ×ˢ t ↔ (x, y) ∈ s₁ ×ˢ t ∪ s₂ ×ˢ t
Theorem: Polynomial.degree_le_mul_left
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp only [hp, MulZeroClass.zero_mul, le_refl]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hq : q ≠ 0
hp : p = 0
⊢ degree p ≤ degree (p * q)

tactic: rw [degree_mul, degree_eq_natDegree hp, degree_eq_natDegree hq]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hq : q ≠ 0
hp : ¬p = 0
⊢ degree p ≤ degree (p * q)

tactic: exact WithBot.coe_le_coe.2 (Nat.le_add_right _ _)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q p : R[X]
hq : q ≠ 0
hp : ¬p = 0
⊢ ↑(natDegree p) ≤ ↑(natDegree p) + ↑(natDegree q)
Theorem: nhdsWithin_union
File: Mathlib/Topology/ContinuousOn.lean

tactic: delta nhdsWithin
state_before: α : Type u_1
β : Type ?u.13810
γ : Type ?u.13813
δ : Type ?u.13816
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ 𝓝[s ∪ t] a = 𝓝[s] a ⊔ 𝓝[t] a

tactic: rw [← inf_sup_left, sup_principal]
state_before: α : Type u_1
β : Type ?u.13810
γ : Type ?u.13813
δ : Type ?u.13816
inst✝ : TopologicalSpace α
a : α
s t : Set α
⊢ 𝓝 a ⊓ 𝓟 (s ∪ t) = 𝓝 a ⊓ 𝓟 s ⊔ 𝓝 a ⊓ 𝓟 t
Theorem: LinearMap.inr_injective
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.54489
M₆ : Type ?u.54492
S : Type ?u.54495
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
x✝ : M₂
⊢ ∀ ⦃a₂ : M₂⦄, ↑(inr R M M₂) x✝ = ↑(inr R M M₂) a₂ → x✝ = a₂
Theorem: Multiset.prod_map_sum
File: Mathlib/Data/Multiset/Sections.lean

tactic: simp
state_before: α : Type u_1
inst✝ : CommSemiring α
s : Multiset (Multiset α)
⊢ prod (map sum 0) = sum (map prod (Sections 0))

tactic: simp [ih, map_bind, sum_map_mul_left, sum_map_mul_right]
state_before: α : Type u_1
inst✝ : CommSemiring α
s✝ : Multiset (Multiset α)
a : Multiset α
s : Multiset (Multiset α)
ih : prod (map sum s) = sum (map prod (Sections s))
⊢ prod (map sum (a ::ₘ s)) = sum (map prod (Sections (a ::ₘ s)))
Theorem: Int.exists_unit_of_abs
File: Mathlib/RingTheory/Int/Basic.lean

tactic: cases' natAbs_eq a with h h
state_before: a : ℤ
⊢ ∃ u x, ↑(natAbs a) = u * a

tactic: use 1, isUnit_one
state_before: case inl
a : ℤ
h : a = ↑(natAbs a)
⊢ ∃ u x, ↑(natAbs a) = u * a

tactic: rw [← h, one_mul]
state_before: case inl
a : ℤ
h : a = ↑(natAbs a)
⊢ ↑(natAbs a) = 1 * a

tactic: use -1, isUnit_one.neg
state_before: case inr
a : ℤ
h : a = -↑(natAbs a)
⊢ ∃ u x, ↑(natAbs a) = u * a

tactic: rw [← neg_eq_iff_eq_neg.mpr h]
state_before: case inr
a : ℤ
h : a = -↑(natAbs a)
⊢ ↑(natAbs a) = -1 * a

tactic: simp only [neg_mul, one_mul]
state_before: case inr
a : ℤ
h : a = -↑(natAbs a)
⊢ -a = -1 * a
Theorem: CategoryTheory.L_faithful_of_unit_isIso
File: Mathlib/CategoryTheory/Adjunction/FullyFaithful.lean

tactic: rw [← (h.homEquiv X (L.obj Y)).apply_eq_iff_eq] at H
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : IsIso h.unit
X Y : C
f g : X ⟶ Y
H : L.map f = L.map g
⊢ f = g

tactic: simpa using H =≫ inv (h.unit.app Y)
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
L : C ⥤ D
R : D ⥤ C
h : L ⊣ R
inst✝ : IsIso h.unit
X Y : C
f g : X ⟶ Y
H : ↑(Adjunction.homEquiv h X (L.obj Y)) (L.map f) = ↑(Adjunction.homEquiv h X (L.obj Y)) (L.map g)
⊢ f = g
Theorem: MeasureTheory.setToFun_add_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1343910
G : Type ?u.1343913
𝕜 : Type ?u.1343916
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
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
f : α → E
⊢ setToFun μ (T + T') (_ : DominatedFinMeasAdditive μ (T + T') (C + C')) f = setToFun μ T hT f + setToFun μ T' hT' f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_add_left hT hT']
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1343910
G : Type ?u.1343913
𝕜 : Type ?u.1343916
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
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
f : α → E
hf : Integrable f
⊢ setToFun μ (T + T') (_ : DominatedFinMeasAdditive μ (T + T') (C + C')) f = setToFun μ T hT f + setToFun μ T' hT' f

tactic: simp_rw [setToFun_undef _ hf, add_zero]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1343910
G : Type ?u.1343913
𝕜 : Type ?u.1343916
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
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
f : α → E
hf : ¬Integrable f
⊢ setToFun μ (T + T') (_ : DominatedFinMeasAdditive μ (T + T') (C + C')) f = setToFun μ T hT f + setToFun μ T' hT' f
Theorem: image2_lowerBounds_lowerBounds_subset_lowerBounds_image2
File: Mathlib/Order/Bounds/Basic.lean

tactic: rintro _ ⟨a, b, ha, hb, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
⊢ image2 f (upperBounds s) (upperBounds t) ⊆ lowerBounds (image2 f s t)

tactic: exact mem_lowerBounds_image2_of_mem_upperBounds h₀ h₁ ha hb
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b✝ : β
h₀ : ∀ (b : β), Antitone (swap f b)
h₁ : ∀ (a : α), Antitone (f a)
a : α
b : β
ha : a ∈ upperBounds s
hb : b ∈ upperBounds t
⊢ f a b ∈ lowerBounds (image2 f s t)