tasksource/leandojo huggingface dataset:
Theorem: MulAction.disjoint_image_image_iff
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: letI := orbitRel α β
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
⊢ Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V

tactic: set f : β → Quotient (MulAction.orbitRel α β) := Quotient.mk'
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
⊢ Disjoint (Quotient.mk' '' U) (Quotient.mk' '' V) ↔ ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V

tactic: refine'
  ⟨fun h x x_in_U a a_in_V =>
    h.le_bot ⟨⟨x, x_in_U, Quotient.sound ⟨a⁻¹, _⟩⟩, ⟨a • x, a_in_V, rfl⟩⟩, _⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
⊢ Disjoint (f '' U) (f '' V) ↔ ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V

tactic: simp
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
h : Disjoint (f '' U) (f '' V)
x : β
x_in_U : x ∈ U
a : α
a_in_V : a • x ∈ V
⊢ (fun x_1 => x_1 • a • x) a⁻¹ = x

tactic: intro h
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
⊢ (∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V) → Disjoint (f '' U) (f '' V)

tactic: rw [Set.disjoint_left]
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
h : ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V
⊢ Disjoint (f '' U) (f '' V)

tactic: rintro x ⟨y, hy₁, hy₂⟩ ⟨z, hz₁, hz₂⟩
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
h : ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V
⊢ ∀ ⦃a : Quotient (orbitRel α β)⦄, a ∈ f '' U → ¬a ∈ f '' V

tactic: obtain ⟨a, rfl⟩ := Quotient.exact (hz₂.trans hy₂.symm)
state_before: case refine'_2.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
h : ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V
x : Quotient (orbitRel α β)
y : β
hy₁ : y ∈ U
hy₂ : f y = x
z : β
hz₁ : z ∈ V
hz₂ : f z = x
⊢ False

tactic: exact h y hy₁ a hz₁
state_before: case refine'_2.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
U V : Set β
this : Setoid β := orbitRel α β
f : β → Quotient (orbitRel α β) := Quotient.mk'
h : ∀ (x : β), x ∈ U → ∀ (a : α), ¬a • x ∈ V
x : Quotient (orbitRel α β)
y : β
hy₁ : y ∈ U
hy₂ : f y = x
a : α
hz₁ : (fun x => x • y) a ∈ V
hz₂ : f ((fun x => x • y) a) = x
⊢ False
Theorem: Complex.abs_re_div_abs_le_one
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [hz, zero_le_one]
state_before: z : ℂ
hz : z = 0
⊢ Abs.abs (z.re / ↑abs z) ≤ 1

tactic: simp_rw [_root_.abs_div, abs_abs,
div_le_iff (AbsoluteValue.pos Complex.abs hz), one_mul, abs_re_le_abs]
state_before: z : ℂ
hz : ¬z = 0
⊢ Abs.abs (z.re / ↑abs z) ≤ 1
Theorem: MvPolynomial.IsHomogeneous.inj_right
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
state_before: σ : Type u_1
τ : Type ?u.155795
R : Type u_2
S : Type ?u.155801
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
m n : ℕ
hm : IsHomogeneous φ m
hn : IsHomogeneous φ n
hφ : φ ≠ 0
⊢ m = n

tactic: rw [← hm hd, ← hn hd]
state_before: case intro
σ : Type u_1
τ : Type ?u.155795
R : Type u_2
S : Type ?u.155801
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
m n : ℕ
hm : IsHomogeneous φ m
hn : IsHomogeneous φ n
hφ : φ ≠ 0
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
Theorem: absorbent_ball_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [← ball_normSeminorm 𝕜]
state_before: R : Type ?u.1453031
R' : Type ?u.1453034
𝕜 : Type u_1
𝕜₂ : Type ?u.1453040
𝕜₃ : Type ?u.1453043
𝕝 : Type ?u.1453046
E : Type u_2
E₂ : Type ?u.1453052
E₃ : Type ?u.1453055
F : Type ?u.1453058
G : Type ?u.1453061
ι : Type ?u.1453064
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
x : E
hr : 0 < r
⊢ Absorbent 𝕜 (Metric.ball 0 r)

tactic: exact (normSeminorm _ _).absorbent_ball_zero hr
state_before: R : Type ?u.1453031
R' : Type ?u.1453034
𝕜 : Type u_1
𝕜₂ : Type ?u.1453040
𝕜₃ : Type ?u.1453043
𝕝 : Type ?u.1453046
E : Type u_2
E₂ : Type ?u.1453052
E₃ : Type ?u.1453055
F : Type ?u.1453058
G : Type ?u.1453061
ι : Type ?u.1453064
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
x : E
hr : 0 < r
⊢ Absorbent 𝕜 (Seminorm.ball (normSeminorm 𝕜 E) 0 r)
Theorem: Ideal.IsPrime.multiset_prod_map_le
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: rw [hp.multiset_prod_le (mt Multiset.map_eq_zero.mp hne)]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset ι
f : ι → Ideal R
P : Ideal R
hp : IsPrime P
hne : s ≠ 0
⊢ Multiset.prod (Multiset.map f s) ≤ P ↔ ∃ i, i ∈ s ∧ f i ≤ P

tactic: simp_rw [Multiset.mem_map, exists_exists_and_eq_and]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
s : Multiset ι
f : ι → Ideal R
P : Ideal R
hp : IsPrime P
hne : s ≠ 0
⊢ (∃ I, I ∈ Multiset.map f s ∧ I ≤ P) ↔ ∃ i, i ∈ s ∧ f i ≤ P
Theorem: Finsupp.toMultiset_map
File: Mathlib/Data/Finsupp/Multiset.lean

tactic: refine' f.induction _ _
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.27283
f : α →₀ ℕ
g : α → β
⊢ Multiset.map g (↑toMultiset f) = ↑toMultiset (mapDomain g f)

tactic: rw [toMultiset_zero, Multiset.map_zero, mapDomain_zero, toMultiset_zero]
state_before: case refine'_1
α : Type u_1
β : Type u_2
ι : Type ?u.27283
f : α →₀ ℕ
g : α → β
⊢ Multiset.map g (↑toMultiset 0) = ↑toMultiset (mapDomain g 0)

tactic: intro a n f _ _ ih
state_before: case refine'_2
α : Type u_1
β : Type u_2
ι : Type ?u.27283
f : α →₀ ℕ
g : α → β
⊢ ∀ (a : α) (b : ℕ) (f : α →₀ ℕ),
    ¬a ∈ f.support →
      b ≠ 0 →
        Multiset.map g (↑toMultiset f) = ↑toMultiset (mapDomain g f) →
          Multiset.map g (↑toMultiset (single a b + f)) = ↑toMultiset (mapDomain g (single a b + f))

tactic: rw [toMultiset_add, Multiset.map_add, ih, mapDomain_add, mapDomain_single,
  toMultiset_single, toMultiset_add, toMultiset_single, ← Multiset.coe_mapAddMonoidHom,
  (Multiset.mapAddMonoidHom g).map_nsmul]
state_before: case refine'_2
α : Type u_1
β : Type u_2
ι : Type ?u.27283
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : ¬a ∈ f.support
a✝ : n ≠ 0
ih : Multiset.map g (↑toMultiset f) = ↑toMultiset (mapDomain g f)
⊢ Multiset.map g (↑toMultiset (single a n + f)) = ↑toMultiset (mapDomain g (single a n + f))

tactic: rfl
state_before: case refine'_2
α : Type u_1
β : Type u_2
ι : Type ?u.27283
f✝ : α →₀ ℕ
g : α → β
a : α
n : ℕ
f : α →₀ ℕ
a✝¹ : ¬a ∈ f.support
a✝ : n ≠ 0
ih : Multiset.map g (↑toMultiset f) = ↑toMultiset (mapDomain g f)
⊢ n • ↑(Multiset.mapAddMonoidHom g) {a} + ↑toMultiset (mapDomain g f) = n • {g a} + ↑toMultiset (mapDomain g f)
Theorem: ack_add_one_sq_lt_ack_add_three
File: Mathlib/Computability/Ackermann.lean

tactic: simpa using sq_le_two_pow_add_one_minus_three (n + 2)
state_before: n : ℕ
⊢ (ack 0 n + 1) ^ 2 ≤ ack (0 + 3) n

tactic: rw [ack_succ_zero, ack_succ_zero]
state_before: m : ℕ
⊢ (ack (m + 1) 0 + 1) ^ 2 ≤ ack (m + 1 + 3) 0

tactic: apply ack_add_one_sq_lt_ack_add_three
state_before: m : ℕ
⊢ (ack m 1 + 1) ^ 2 ≤ ack (m + 3) 1

tactic: rw [ack_succ_succ, ack_succ_succ]
state_before: m n : ℕ
⊢ (ack (m + 1) (n + 1) + 1) ^ 2 ≤ ack (m + 1 + 3) (n + 1)

tactic: apply (ack_add_one_sq_lt_ack_add_three _ _).trans (ack_mono_right _ <| ack_mono_left _ _)
state_before: m n : ℕ
⊢ (ack m (ack (m + 1) n) + 1) ^ 2 ≤ ack (m + 3) (ack (m + 3 + 1) n)

tactic: linarith
state_before: m n : ℕ
⊢ m + 1 ≤ m + 3 + 1
Theorem: CategoryTheory.Limits.HasColimit.isoOfEquivalence_hom_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: simp [HasColimit.isoOfEquivalence, IsColimit.coconePointsIsoOfEquivalence_inv]
state_before: J : Type u₁
inst✝⁴ : Category J
K : Type u₂
inst✝³ : Category K
C : Type u
inst✝² : Category C
F✝ F : J ⥤ C
inst✝¹ : HasColimit F
G : K ⥤ C
inst✝ : HasColimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ colimit.ι F j ≫ (isoOfEquivalence e w).hom =
    F.map ((Equivalence.unit e).app j) ≫
      w.inv.app ((e.functor ⋙ e.inverse).obj j) ≫ colimit.ι G (e.functor.obj ((e.functor ⋙ e.inverse).obj j))
Theorem: Finset.neg_smul
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← image_neg]
state_before: F : Type ?u.951428
α : Type u_1
β : Type u_2
γ : Type ?u.951437
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ -s • t = -(s • t)

tactic: exact image₂_image_left_comm neg_smul
state_before: F : Type ?u.951428
α : Type u_1
β : Type u_2
γ : Type ?u.951437
inst✝⁴ : Ring α
inst✝³ : AddCommGroup β
inst✝² : Module α β
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝ : DecidableEq α
⊢ image (fun x => -x) s • t = image (fun x => -x) (s • t)
Theorem: Ordering.Compares.ne_lt
File: Mathlib/Order/Compare.lean

tactic: injection h
state_before: α : Type u_1
β : Type ?u.6902
inst✝ : Preorder α
a b : α
h✝ : Compares eq a b
x✝ : b ≤ a
h : eq = lt
⊢ False

tactic: injection h
state_before: α : Type u_1
β : Type ?u.6902
inst✝ : Preorder α
a b : α
h✝ : Compares gt a b
x✝ : b ≤ a
h : gt = lt
⊢ False
Theorem: Set.ncard_eq_toFinset_card
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_def, @Nat.card_eq_fintype_card _ hs.fintype, @Finite.card_toFinset _ _ hs.fintype hs]
state_before: α : Type u_1
β : Type ?u.2365
s✝ t : Set α
a b x y : α
f : α → β
s : Set α
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard s = Finset.card (Finite.toFinset hs)
Theorem: vsub_vadd_comm
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [← @vsub_eq_zero_iff_eq G, vadd_vsub_assoc, vsub_vadd_eq_vsub_sub]
state_before: G : Type u_2
P : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
p1 p2 p3 : P
⊢ p1 -ᵥ p2 +ᵥ p3 = p3 -ᵥ p2 +ᵥ p1

tactic: simp
state_before: G : Type u_2
P : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
p1 p2 p3 : P
⊢ p1 -ᵥ p2 + (p3 -ᵥ p1 - (p3 -ᵥ p2)) = 0
Theorem: div_le_div_of_nonpos_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_eq_mul_one_div a c, div_eq_mul_one_div b c]
state_before: ι : Type ?u.152300
α : Type u_1
β : Type ?u.152306
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c ≤ 0
h : b ≤ a
⊢ a / c ≤ b / c

tactic: exact mul_le_mul_of_nonpos_right h (one_div_nonpos.2 hc)
state_before: ι : Type ?u.152300
α : Type u_1
β : Type ?u.152306
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c ≤ 0
h : b ≤ a
⊢ a * (1 / c) ≤ b * (1 / c)
Theorem: Polynomial.support_binomial
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: apply subset_antisymm (support_binomial' k m x y)
state_before: R : Type u
S : Type v
a b : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m : ℕ
hkm : k ≠ m
x y : R
hx : x ≠ 0
hy : y ≠ 0
⊢ support (↑C x * X ^ k + ↑C y * X ^ m) = {k, m}

tactic: simp_rw [insert_subset, singleton_subset_iff, mem_support_iff, coeff_add, coeff_C_mul,
  coeff_X_pow_self, mul_one, coeff_X_pow, if_neg hkm, if_neg hkm.symm, mul_zero, zero_add,
  add_zero, Ne.def, hx, hy]
state_before: R : Type u
S : Type v
a b : R
n m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m : ℕ
hkm : k ≠ m
x y : R
hx : x ≠ 0
hy : y ≠ 0
⊢ {k, m} ⊆ support (↑C x * X ^ k + ↑C y * X ^ m)
Theorem: ENNReal.tsum_le_tsum_comp_of_surjective
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [surjInv_eq hf]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.275475
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g✝ : α → ℝ≥0∞
f : α → β
hf : Surjective f
g : β → ℝ≥0∞
⊢ (∑' (y : β), g y) = ∑' (y : β), g (f (surjInv hf y))
Theorem: Ordinal.opow_le_opow_left
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: by_cases a0 : a = 0
state_before: a b c : Ordinal
ab : a ≤ b
⊢ a ^ c ≤ b ^ c

tactic: subst a
state_before: case pos
a b c : Ordinal
ab : a ≤ b
a0 : a = 0
⊢ a ^ c ≤ b ^ c

tactic: by_cases c0 : c = 0
state_before: case pos
b c : Ordinal
ab : 0 ≤ b
⊢ 0 ^ c ≤ b ^ c

tactic: subst c
state_before: case pos
b c : Ordinal
ab : 0 ≤ b
c0 : c = 0
⊢ 0 ^ c ≤ b ^ c

tactic: simp only [opow_zero, le_refl]
state_before: case pos
b : Ordinal
ab : 0 ≤ b
⊢ 0 ^ 0 ≤ b ^ 0

tactic: simp only [zero_opow c0, Ordinal.zero_le]
state_before: case neg
b c : Ordinal
ab : 0 ≤ b
c0 : ¬c = 0
⊢ 0 ^ c ≤ b ^ c

tactic: apply limitRecOn c
state_before: case neg
a b c : Ordinal
ab : a ≤ b
a0 : ¬a = 0
⊢ a ^ c ≤ b ^ c

tactic: simp only [opow_zero, le_refl]
state_before: case neg.H₁
a b c : Ordinal
ab : a ≤ b
a0 : ¬a = 0
⊢ a ^ 0 ≤ b ^ 0

tactic: intro c IH
state_before: case neg.H₂
a b c : Ordinal
ab : a ≤ b
a0 : ¬a = 0
⊢ ∀ (o : Ordinal), a ^ o ≤ b ^ o → a ^ succ o ≤ b ^ succ o

tactic: simpa only [opow_succ] using mul_le_mul' IH ab
state_before: case neg.H₂
a b c✝ : Ordinal
ab : a ≤ b
a0 : ¬a = 0
c : Ordinal
IH : a ^ c ≤ b ^ c
⊢ a ^ succ c ≤ b ^ succ c

tactic: exact fun c l IH =>
  (opow_le_of_limit a0 l).2 fun b' h =>
    (IH _ h).trans (opow_le_opow_right ((Ordinal.pos_iff_ne_zero.2 a0).trans_le ab) h.le)
state_before: case neg.H₃
a b c : Ordinal
ab : a ≤ b
a0 : ¬a = 0
⊢ ∀ (o : Ordinal), IsLimit o → (∀ (o' : Ordinal), o' < o → a ^ o' ≤ b ^ o') → a ^ o ≤ b ^ o
Theorem: Filter.hasBasis_iInf_of_directed
File: Mathlib/Order/Filter/Bases.lean

tactic: refine' ⟨fun t => _⟩
state_before: α : Type u_3
β : Type ?u.35963
γ : Type ?u.35966
ι✝ : Sort ?u.35969
ι'✝ : Sort ?u.35972
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : ι → ι' → Set α
p : ι → ι' → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
⊢ HasBasis (⨅ (i : ι), l i) (fun ii' => p ii'.fst ii'.snd) fun ii' => s ii'.fst ii'.snd

tactic: rw [mem_iInf_of_directed h, Prod.exists]
state_before: α : Type u_3
β : Type ?u.35963
γ : Type ?u.35966
ι✝ : Sort ?u.35969
ι'✝ : Sort ?u.35972
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : ι → ι' → Set α
p : ι → ι' → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
t : Set α
⊢ (t ∈ ⨅ (i : ι), l i) ↔ ∃ i, p i.fst i.snd ∧ s i.fst i.snd ⊆ t

tactic: exact exists_congr fun i => (hl i).mem_iff
state_before: α : Type u_3
β : Type ?u.35963
γ : Type ?u.35966
ι✝ : Sort ?u.35969
ι'✝ : Sort ?u.35972
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : ι → ι' → Set α
p : ι → ι' → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
t : Set α
⊢ (∃ i, t ∈ l i) ↔ ∃ a b, p (a, b).fst (a, b).snd ∧ s (a, b).fst (a, b).snd ⊆ t
Theorem: Set.image_neg_Ico
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Ico a b = Ioc (-b) (-a)
Theorem: lineMap_le_right_iff_le
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rw [lineMap_apply_one]
state_before: k : Type u_1
E : Type u_2
PE : Type ?u.106644
inst✝³ : LinearOrderedField k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a b : E
r r' : k
h : r < 1
⊢ ↑(lineMap a b) r ≤ b ↔ ↑(lineMap a b) r ≤ ↑(lineMap a b) 1
Theorem: CategoryTheory.PreservesFiniteLimitsOfFlat.fac
File: Mathlib/CategoryTheory/Functor/Flat.lean

tactic: simp [lift, ← Functor.map_comp]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
J : Type v₁
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
K : J ⥤ C
F : C ⥤ D
inst✝ : RepresentablyFlat F
c : Cone K
hc : IsLimit c
s : Cone (K ⋙ F)
x : J
⊢ lift F hc s ≫ (F.mapCone c).π.app x = s.π.app x
Theorem: Set.preimage_eq_empty_iff
File: Mathlib/Data/Set/Image.lean

tactic: simp only [eq_empty_iff_forall_not_mem, disjoint_iff_inter_eq_empty, not_exists, mem_inter_iff,
  not_and, mem_range, mem_preimage] at h ⊢
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.121829
f : α → β
s✝ t : Set α
s : Set β
h : f ⁻¹' s = ∅
⊢ Disjoint s (range f)

tactic: intro y hy x hx
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.121829
f : α → β
s✝ t : Set α
s : Set β
h : ∀ (x : α), ¬f x ∈ s
⊢ ∀ (x : β), x ∈ s → ∀ (x_1 : α), ¬f x_1 = x

tactic: rw [← hx] at hy
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.121829
f : α → β
s✝ t : Set α
s : Set β
h : ∀ (x : α), ¬f x ∈ s
y : β
hy : y ∈ s
x : α
hx : f x = y
⊢ False

tactic: exact h x hy
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.121829
f : α → β
s✝ t : Set α
s : Set β
h : ∀ (x : α), ¬f x ∈ s
y : β
x : α
hy : f x ∈ s
hx : f x = y
⊢ False
Theorem: Disjoint.disjoint_sup_right_of_disjoint_sup_left
File: Mathlib/Order/ModularLattice.lean

tactic: rw [disjoint_iff_inf_le, ← h.eq_bot, sup_comm]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ Disjoint a (b ⊔ c)

tactic: apply le_inf inf_le_left
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ a ⊓ b

tactic: apply (inf_le_inf_right (c ⊔ b) le_sup_right).trans
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ b

tactic: rw [sup_comm, IsModularLattice.sup_inf_sup_assoc, hsup.eq_bot, bot_sup_eq]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ (?m.26537 ⊔ a) ⊓ (c ⊔ b) ≤ b

α : Type u_1
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
a b c : α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ α
Theorem: Finsupp.neLocus_zero_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_1
M : Type ?u.6134
N : Type u_2
P : Type ?u.6140
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
⊢ neLocus f 0 = f.support

tactic: rw [mem_neLocus, mem_support_iff, coe_zero, Pi.zero_apply]
state_before: case a
α : Type u_1
M : Type ?u.6134
N : Type u_2
P : Type ?u.6140
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
a✝ : α
⊢ a✝ ∈ neLocus f 0 ↔ a✝ ∈ f.support
Theorem: norm_fderivWithin_iteratedFDerivWithin
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [iteratedFDerivWithin_succ_eq_comp_left, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
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 uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ‖fderivWithin 𝕜 (iteratedFDerivWithin 𝕜 n f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n + 1) f s x‖
Theorem: MeasureTheory.snorm_const
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: by_cases h_top : p = ∞
state_before: α : Type u_1
E : Type ?u.1109806
F : Type u_2
G : Type ?u.1109812
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * ↑↑μ Set.univ ^ (1 / ENNReal.toReal p)

tactic: simp [snorm_eq_snorm' h0 h_top, snorm'_const, ENNReal.toReal_pos h0 h_top]
state_before: case neg
α : Type u_1
E : Type ?u.1109806
F : Type u_2
G : Type ?u.1109812
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : ¬p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * ↑↑μ Set.univ ^ (1 / ENNReal.toReal p)

tactic: simp [h_top, snormEssSup_const c hμ]
state_before: case pos
α : Type u_1
E : Type ?u.1109806
F : Type u_2
G : Type ?u.1109812
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * ↑↑μ Set.univ ^ (1 / ENNReal.toReal p)
Theorem: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_tsum_measure
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: contrapose! H
state_before: α : Type u_1
β : Type ?u.41179
γ : Type ?u.41182
δ : Type ?u.41185
ι : Type u_2
R : Type ?u.41191
R' : Type ?u.41194
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : ↑↑μ univ < ∑' (i : ι), ↑↑μ (s i)
⊢ ∃ i j _h, Set.Nonempty (s i ∩ s j)

tactic: apply tsum_measure_le_measure_univ hs
state_before: α : Type u_1
β : Type ?u.41179
γ : Type ?u.41182
δ : Type ?u.41185
ι : Type u_2
R : Type ?u.41191
R' : Type ?u.41194
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : ∀ (i j : ι), i ≠ j → ¬Set.Nonempty (s i ∩ s j)
⊢ (∑' (i : ι), ↑↑μ (s i)) ≤ ↑↑μ univ

tactic: intro i j hij
state_before: α : Type u_1
β : Type ?u.41179
γ : Type ?u.41182
δ : Type ?u.41185
ι : Type u_2
R : Type ?u.41191
R' : Type ?u.41194
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : ∀ (i j : ι), i ≠ j → ¬Set.Nonempty (s i ∩ s j)
⊢ Pairwise (Disjoint on fun i => s i)

tactic: rw [Function.onFun, disjoint_iff_inf_le]
state_before: α : Type u_1
β : Type ?u.41179
γ : Type ?u.41182
δ : Type ?u.41185
ι : Type u_2
R : Type ?u.41191
R' : Type ?u.41194
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : ∀ (i j : ι), i ≠ j → ¬Set.Nonempty (s i ∩ s j)
i j : ι
hij : i ≠ j
⊢ (Disjoint on fun i => s i) i j

tactic: exact fun x hx => H i j hij ⟨x, hx⟩
state_before: α : Type u_1
β : Type ?u.41179
γ : Type ?u.41182
δ : Type ?u.41185
ι : Type u_2
R : Type ?u.41191
R' : Type ?u.41194
m✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
m : MeasurableSpace α
μ : Measure α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : ∀ (i j : ι), i ≠ j → ¬Set.Nonempty (s i ∩ s j)
i j : ι
hij : i ≠ j
⊢ s i ⊓ s j ≤ ⊥
Theorem: Option.pbind_eq_bind
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [pbind, none_bind', some_bind']
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.4731
δ : Type ?u.4734
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : α → Option β
x : Option α
⊢ (pbind x fun a x => f a) = Option.bind x f
Theorem: PGame.moveRight_neg_symm
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp
state_before: x : PGame
i : LeftMoves (-x)
⊢ moveRight x (↑toLeftMovesNeg.symm i) = -moveLeft (-x) i
Theorem: CategoryTheory.Limits.pullback_map_eq_pullbackFstFstIso_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: simp only [pullbackFstFstIso_inv, lift_snd_assoc, lift_fst]
state_before: C : Type u_2
inst✝² : Category C
X✝ Y✝ Z : C
inst✝¹ : HasPullbacks C
X Y S X' Y' S' : C
f : X ⟶ S
g : Y ⟶ S
f' : X' ⟶ S'
g' : Y' ⟶ S'
i₁ : X ⟶ X'
i₂ : Y ⟶ Y'
i₃ : S ⟶ S'
e₁ : f ≫ i₃ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₂ ≫ g'
inst✝ : Mono i₃
⊢ map f g f' g' i₁ i₂ i₃ e₁ e₂ = (pullbackFstFstIso f g f' g' i₁ i₂ i₃ e₁ e₂).inv ≫ snd ≫ fst