tasksource/leandojo huggingface dataset:
Theorem: Set.preimage_subtype_coe_eq_compl
File: Mathlib/Data/Set/Image.lean

tactic: ext ⟨x, x_in_s⟩
state_before: α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
⊢ Subtype.val ⁻¹' u = (Subtype.val ⁻¹' v)ᶜ

tactic: constructor
state_before: case h.mk
α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
x : α
x_in_s : x ∈ s
⊢ { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' u ↔ { val := x, property := x_in_s } ∈ (Subtype.val ⁻¹' v)ᶜ

tactic: intro x_in_u x_in_v
state_before: case h.mk.mp
α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
x : α
x_in_s : x ∈ s
⊢ { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' u → { val := x, property := x_in_s } ∈ (Subtype.val ⁻¹' v)ᶜ

tactic: exact eq_empty_iff_forall_not_mem.mp H x ⟨x_in_s, ⟨x_in_u, x_in_v⟩⟩
state_before: case h.mk.mp
α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
x : α
x_in_s : x ∈ s
x_in_u : { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' u
x_in_v : { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' v
⊢ False

tactic: intro hx
state_before: case h.mk.mpr
α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
x : α
x_in_s : x ∈ s
⊢ { val := x, property := x_in_s } ∈ (Subtype.val ⁻¹' v)ᶜ → { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' u

tactic: exact Or.elim (hsuv x_in_s) id fun hx' => hx.elim hx'
state_before: case h.mk.mpr
α✝ : Type ?u.12591
β : Type ?u.12594
γ : Type ?u.12597
ι : Sort ?u.12600
ι' : Sort ?u.12603
f : α✝ → β
g : β → γ
α : Type u_1
s u v : Set α
hsuv : s ⊆ u ∪ v
H : s ∩ (u ∩ v) = ∅
x : α
x_in_s : x ∈ s
hx : { val := x, property := x_in_s } ∈ (Subtype.val ⁻¹' v)ᶜ
⊢ { val := x, property := x_in_s } ∈ Subtype.val ⁻¹' u
Theorem: ENNReal.tsum_toReal_eq
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [ENNReal.toReal, tsum_toNNReal_eq hf, NNReal.coe_tsum]
state_before: α : Type u_1
β : Type ?u.333384
γ : Type ?u.333387
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≠ ⊤
⊢ ENNReal.toReal (∑' (a : α), f a) = ∑' (a : α), ENNReal.toReal (f a)
Theorem: Subsemigroup.mem_iSup_of_mem
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: have : S i ≤ iSup S := le_iSup _ _
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.8697
B : Type ?u.8700
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S

tactic: tauto
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.8697
B : Type ?u.8700
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
this : S i ≤ iSup S
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
Theorem: Int.neg_one_pow_ne_zero
File: Mathlib/Data/Int/Order/Units.lean

tactic: simp
state_before: n : ℕ
⊢ 0 < abs (-1)
Theorem: round_nat_add
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [add_comm, round_add_nat, add_comm]
state_before: F : Type ?u.258505
α : Type u_1
β : Type ?u.258511
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
x : α
y : ℕ
⊢ round (↑y + x) = ↑y + round x
Theorem: Polynomial.eraseLead_zero
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: simp only [eraseLead, erase_zero]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ eraseLead 0 = 0
Theorem: Option.choice_eq
File: Std/Data/Option/Lemmas.lean

tactic: simp [choice]
state_before: α : Type u_1
inst✝ : Subsingleton α
a : α
⊢ choice α = some a

tactic: rw [dif_pos (⟨a⟩ : Nonempty α)]
state_before: α : Type u_1
inst✝ : Subsingleton α
a : α
⊢ (if h : Nonempty α then some (Classical.choice h) else none) = some a

tactic: simp
state_before: α : Type u_1
inst✝ : Subsingleton α
a : α
⊢ some (Classical.choice (_ : Nonempty α)) = some a

tactic: apply Subsingleton.elim
state_before: α : Type u_1
inst✝ : Subsingleton α
a : α
⊢ Classical.choice (_ : Nonempty α) = a
Theorem: MultilinearMap.curryFinFinset_symm_apply_piecewise_const_aux
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: have := curryFinFinset_symm_apply_piecewise_const hk hl f x y
state_before: R : Type u
ι : Type u'
n✝ : ℕ
M : Fin (Nat.succ n✝) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n✝)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n✝)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
ι' : Type ?u.760748
k l n : ℕ
s : Finset (Fin n)
hk : Finset.card s = k
hl : Finset.card (sᶜ) = l
f : MultilinearMap R (fun x => M') (MultilinearMap R (fun x => M') M₂)
x y : M'
⊢ (↑(↑f fun x_1 => x) fun i =>
      Finset.piecewise s (fun x_1 => x) (fun x => y) (↑(finSumEquivOfFinset hk hl) (Sum.inr i))) =
    ↑(↑f fun x_1 => x) fun x => y

tactic: simp only [curryFinFinset_symm_apply, finSumEquivOfFinset_inl, Finset.orderEmbOfFin_mem,
Finset.piecewise_eq_of_mem, finSumEquivOfFinset_inr] at this
state_before: R : Type u
ι : Type u'
n✝ : ℕ
M : Fin (Nat.succ n✝) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n✝)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n✝)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
ι' : Type ?u.760748
k l n : ℕ
s : Finset (Fin n)
hk : Finset.card s = k
hl : Finset.card (sᶜ) = l
f : MultilinearMap R (fun x => M') (MultilinearMap R (fun x => M') M₂)
x y : M'
this :
  ↑(↑(LinearEquiv.symm (curryFinFinset R M₂ M' hk hl)) f) (Finset.piecewise s (fun x_1 => x) fun x => y) =
    ↑(↑f fun x_1 => x) fun x => y
⊢ (↑(↑f fun x_1 => x) fun i =>
      Finset.piecewise s (fun x_1 => x) (fun x => y) (↑(finSumEquivOfFinset hk hl) (Sum.inr i))) =
    ↑(↑f fun x_1 => x) fun x => y

tactic: exact this
state_before: R : Type u
ι : Type u'
n✝ : ℕ
M : Fin (Nat.succ n✝) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁶ : CommSemiring R
inst✝⁵ : (i : Fin (Nat.succ n✝)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M₂
inst✝² : (i : Fin (Nat.succ n✝)) → Module R (M i)
inst✝¹ : Module R M'
inst✝ : Module R M₂
ι' : Type ?u.760748
k l n : ℕ
s : Finset (Fin n)
hk : Finset.card s = k
hl : Finset.card (sᶜ) = l
f : MultilinearMap R (fun x => M') (MultilinearMap R (fun x => M') M₂)
x y : M'
this :
  (↑(↑f fun i => x) fun i =>
      Finset.piecewise s (fun x_1 => x) (fun x => y) (↑(finSumEquivOfFinset hk hl) (Sum.inr i))) =
    ↑(↑f fun i => x) fun x => y
⊢ (↑(↑f fun x_1 => x) fun i =>
      Finset.piecewise s (fun x_1 => x) (fun x => y) (↑(finSumEquivOfFinset hk hl) (Sum.inr i))) =
    ↑(↑f fun x_1 => x) fun x => y
Theorem: CategoryTheory.Sieve.le_pullback_bind
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rw [← galoisConnection f]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ R h ≤ pullback f (bind S R)

tactic: apply pushforward_le_bind_of_mem
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
S : Presieve X
R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → Sieve Y
f : Y ⟶ X
h : S f
⊢ pushforward f (R h) ≤ bind S R
Theorem: dualTensorHom_prodMap_zero
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext <;>
  simp only [coe_comp, coe_inl, Function.comp_apply, prodMap_apply, dualTensorHom_apply,
    fst_apply, Prod.smul_mk, LinearMap.zero_apply, smul_zero]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
p : P
⊢ prodMap (↑(dualTensorHom R M P) (f ⊗ₜ[R] p)) 0 =
    ↑(dualTensorHom R (M × N) (P × Q)) (comp f (fst R M N) ⊗ₜ[R] ↑(inl R P Q) p)
Theorem: Finset.coe_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_coe, mem_insert, Set.mem_insert_iff]
state_before: α : Type u_1
β : Type ?u.105476
γ : Type ?u.105479
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
x : α
⊢ x ∈ ↑(insert a s) ↔ x ∈ insert a ↑s
Theorem: CategoryTheory.Limits.spanExt_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).app WalkingSpan.left = iY
Theorem: closedBall_add_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [(isCompact_closedBall _ _).add_closedBall hδ b, cthickening_closedBall hδ hε a,
  Metric.vadd_closedBall, vadd_eq_add, add_comm, add_comm δ]
state_before: 𝕜 : Type ?u.1476288
E : Type u_1
inst✝⁴ : NormedField 𝕜
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
inst✝ : ProperSpace E
hε : 0 ≤ ε
hδ : 0 ≤ δ
a b : E
⊢ Metric.closedBall a ε + Metric.closedBall b δ = Metric.closedBall (a + b) (ε + δ)
Theorem: Collinear.coplanar_insert
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have : FiniteDimensional k { x // x ∈ vectorSpan k s } := h.finiteDimensional_vectorSpan
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p : P
⊢ Coplanar k (insert p s)

tactic: rw [coplanar_iff_finrank_le_two]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p : P
this : FiniteDimensional k { x // x ∈ vectorSpan k s }
⊢ Coplanar k (insert p s)

tactic: exact (finrank_vectorSpan_insert_le_set k s p).trans (add_le_add_right h.finrank_le_one _)
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : Set P
h : Collinear k s
p : P
this : FiniteDimensional k { x // x ∈ vectorSpan k s }
⊢ finrank k { x // x ∈ vectorSpan k (insert p s) } ≤ 2
Theorem: Matrix.transvection_mul_transvection_same
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection, Matrix.add_mul, Matrix.mul_add, h, h.symm, add_smul, add_assoc,
  stdBasisMatrix_add]
state_before: n : Type u_1
p : Type ?u.9953
R : Type u₂
𝕜 : Type ?u.9958
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
h : i ≠ j
c d : R
⊢ transvection i j c ⬝ transvection i j d = transvection i j (c + d)
Theorem: Zsqrtd.nonneg_iff_zero_le
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: simp
state_before: d : ℕ
a : ℤ√↑d
⊢ Nonneg a ↔ Nonneg (a - 0)
Theorem: Ordnode.all_balanceR
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balanceR_eq_balance' hl hr sl sr H, all_balance']
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
hl : Balanced l
hr : Balanced r
sl : Sized l
sr : Sized r
H : (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨ ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r'
⊢ All P (balanceR l x r) ↔ All P l ∧ P x ∧ All P r
Theorem: mul_le_of_one_le_left
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [one_mul] using mul_le_mul_of_nonpos_right h hb
state_before: α : Type u
β : Type ?u.41158
inst✝ : OrderedRing α
a b c d : α
hb : b ≤ 0
h : 1 ≤ a
⊢ a * b ≤ b
Theorem: CategoryTheory.StructuredArrow.eq_mk
File: Mathlib/CategoryTheory/StructuredArrow.lean

tactic: cases f
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
f : StructuredArrow S T
⊢ f = mk f.hom

tactic: congr
state_before: case mk
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S S' S'' : D
Y Y' : C
T : C ⥤ D
left✝ : Discrete PUnit
right✝ : C
hom✝ : (Functor.fromPUnit S).obj left✝ ⟶ T.obj right✝
⊢ { left := left✝, right := right✝, hom := hom✝ } = mk { left := left✝, right := right✝, hom := hom✝ }.hom
Theorem: Int.floor_intCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_floor, Int.cast_le]
state_before: F : Type ?u.126743
α : Type u_1
β : Type ?u.126749
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ : α
z a : ℤ
⊢ a ≤ ⌊↑z⌋ ↔ a ≤ z
Theorem: AList.mem_replace
File: Mathlib/Data/List/AList.lean

tactic: rw [mem_keys, keys_replace, ← mem_keys]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
s : AList β
⊢ a' ∈ replace a b s ↔ a' ∈ s
Theorem: AList.keys_insert
File: Mathlib/Data/List/AList.lean

tactic: simp [insert, keys, keys_kerase]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
⊢ keys (insert a b s) = a :: List.erase (keys s) a
Theorem: Equiv.Perm.card_support_swap
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp [hxy]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hxy : x ≠ y
⊢ Multiset.Nodup (x ::ₘ y ::ₘ 0)

tactic: simp [support_swap hxy, *, Finset.ext_iff]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
x y : α
hxy : x ≠ y
⊢ support (swap x y) = { val := x ::ₘ y ::ₘ 0, nodup := (_ : Multiset.Nodup (x ::ₘ {y})) }
Theorem: LinearMap.toMatrixAlgEquiv_comp
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp [LinearMap.toMatrixAlgEquiv, LinearMap.toMatrix_comp v₁ v₁ v₁ f g]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2626461
m : Type ?u.2626464
n : Type u_3
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_2
M₂ : Type ?u.2626488
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2626990
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f g : M₁ →ₗ[R] M₁
⊢ ↑(toMatrixAlgEquiv v₁) (comp f g) = ↑(toMatrixAlgEquiv v₁) f ⬝ ↑(toMatrixAlgEquiv v₁) g
Theorem: ZNum.cast_bit0
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [ZNum.bit0, cast_pos, cast_pos]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(ZNum.bit0 (pos p)) = _root_.bit0 ↑(pos p)

tactic: rfl
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(PosNum.bit0 p) = _root_.bit0 ↑p

tactic: rw [ZNum.bit0, cast_neg, cast_neg, PosNum.cast_bit0, _root_.bit0, _root_.bit0, neg_add_rev]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(ZNum.bit0 (neg p)) = _root_.bit0 ↑(neg p)
Theorem: Sylow.normalizer_sup_eq_top'
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← Sylow.normalizer_sup_eq_top (P.subtype hP), P.coe_subtype, subgroupOf_map_subtype,
  inf_of_le_left hP]
state_before: p✝ : ℕ
G : Type u_1
inst✝³ : Group G
p : ℕ
inst✝² : Fact (Nat.Prime p)
N : Subgroup G
inst✝¹ : Normal N
inst✝ : Finite (Sylow p { x // x ∈ N })
P : Sylow p G
hP : ↑P ≤ N
⊢ normalizer ↑P ⊔ N = ⊤
Theorem: Finset.map_cons
File: Mathlib/Data/Finset/Image.lean

tactic: simpa using ha
state_before: α : Type ?u.42059
β : Type ?u.42062
γ : Type ?u.42065
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
a : α
s : Finset α
ha : ¬a ∈ s
⊢ ¬↑f a ∈ map f s
Theorem: Dfinsupp.neLocus_zero_right
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
⊢ neLocus f 0 = support f

tactic: rw [mem_neLocus, mem_support_iff, coe_zero, Pi.zero_apply]
state_before: case a
α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
a✝ : α
⊢ a✝ ∈ neLocus f 0 ↔ a✝ ∈ support f
Theorem: SimpleGraph.Walk.length_dropUntil_le
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: have := congr_arg Walk.length (p.take_spec h)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
⊢ length (dropUntil p u h) ≤ length p

tactic: rw [length_append, add_comm] at this
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
this : length (append (takeUntil p u h) (dropUntil p u h)) = length p
⊢ length (dropUntil p u h) ≤ length p

tactic: exact Nat.le.intro this
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
this : length (dropUntil p u h) + length (takeUntil p u h) = length p
⊢ length (dropUntil p u h) ≤ length p
Theorem: Nat.odd_mul_odd_div_two
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp_all
state_before: m✝ n✝ a b c d m n : ℕ
hm1 : m % 2 = 1
hn1 : n % 2 = 1
h : m = 0
⊢ False

tactic: simp_all
state_before: m✝ n✝ a b c d m n : ℕ
hm1 : m % 2 = 1
hn1 : n % 2 = 1
hm0 : 0 < m
h : n = 0
⊢ False

tactic: dsimp
state_before: m✝ n✝ a b c d m n : ℕ
hm1 : m % 2 = 1
hn1 : n % 2 = 1
hm0 : 0 < m
hn0 : 0 < n
⊢ (fun x x_1 => x * x_1) 2 (m * n / 2) = (fun x x_1 => x * x_1) 2 (m * (n / 2) + m / 2)

tactic: rw [mul_add, two_mul_odd_div_two hm1, mul_left_comm, two_mul_odd_div_two hn1,
  two_mul_odd_div_two (Nat.odd_mul_odd hm1 hn1), mul_tsub, mul_one, ←
  add_tsub_assoc_of_le (succ_le_of_lt hm0),
  tsub_add_cancel_of_le (le_mul_of_one_le_right (Nat.zero_le _) hn0)]
state_before: m✝ n✝ a b c d m n : ℕ
hm1 : m % 2 = 1
hn1 : n % 2 = 1
hm0 : 0 < m
hn0 : 0 < n
⊢ 2 * (m * n / 2) = 2 * (m * (n / 2) + m / 2)
Theorem: smul_closedUnitBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_closedBall _ _ zero_le_one, smul_zero, mul_one]
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
c : 𝕜
⊢ c • closedBall 0 1 = closedBall 0 ‖c‖
Theorem: Dfinsupp.mapRange_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y
g₁ g₂ : Π₀ (i : ι), β₁ i
⊢ mapRange f hf (g₁ + g₂) = mapRange f hf g₁ + mapRange f hf g₂

tactic: simp only [mapRange_apply f, coe_add, Pi.add_apply, hf']
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : (i : ι) → AddZeroClass (β₁ i)
inst✝ : (i : ι) → AddZeroClass (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
hf' : ∀ (i : ι) (x y : β₁ i), f i (x + y) = f i x + f i y
g₁ g₂ : Π₀ (i : ι), β₁ i
i✝ : ι
⊢ ↑(mapRange f hf (g₁ + g₂)) i✝ = ↑(mapRange f hf g₁ + mapRange f hf g₂) i✝
Theorem: aEMeasurable_coe_nnreal_real_iff
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simpa only [Real.toNNReal_coe] using h.real_toNNReal
state_before: α : Type u_1
β : Type ?u.2694217
γ : Type ?u.2694220
γ₂ : Type ?u.2694223
δ : Type ?u.2694226
ι : Sort y
s t u : Set α
inst✝ : MeasurableSpace α
f : α → ℝ≥0
μ : MeasureTheory.Measure α
h : AEMeasurable fun x => ↑(f x)
⊢ AEMeasurable f
Theorem: ENNReal.sInf_add
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [sInf_eq_iInf, iInf_add]
state_before: α : Type ?u.853270
β : Type ?u.853273
a b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort ?u.853290
f g : ι → ℝ≥0∞
s : Set ℝ≥0∞
⊢ sInf s + a = ⨅ (b : ℝ≥0∞) (_ : b ∈ s), b + a
Theorem: Bool.and_comm
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b : Bool), (a && b) = (b && a)
Theorem: iSup_range'
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup, iSup, ← image_eq_range, ← range_comp]
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.63820
γ : Type ?u.63823
ι : Sort u_3
ι' : Sort ?u.63829
κ : ι → Sort ?u.63834
κ' : ι' → Sort ?u.63839
inst✝ : SupSet α
f✝ g✝ : ι → α
g : β → α
f : ι → β
⊢ (⨆ (b : ↑(range f)), g ↑b) = ⨆ (i : ι), g (f i)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.63820
γ : Type ?u.63823
ι : Sort u_3
ι' : Sort ?u.63829
κ : ι → Sort ?u.63834
κ' : ι' → Sort ?u.63839
inst✝ : SupSet α
f✝ g✝ : ι → α
g : β → α
f : ι → β
⊢ sSup (range (g ∘ f)) = sSup (range fun i => g (f i))
Theorem: AddCommGroup.modEq_neg
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, ← neg_eq_iff_eq_neg]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ b ≡ a [PMOD -p] ↔ a ≡ b [PMOD p]
Theorem: BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: refine' (mem_split_iff'.1 h₁).resolve_left fun H => _
state_before: ι : Type u_1
M : Type ?u.38063
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : x < y i
⊢ ↑J = ↑I ∩ {y | x < y i}

tactic: rw [← Box.mem_coe, H] at h₂
state_before: ι : Type u_1
M : Type ?u.38063
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : x < y i
H : ↑J = ↑I ∩ {y | y i ≤ x}
⊢ False

tactic: exact h₃.not_le h₂.2
state_before: ι : Type u_1
M : Type ?u.38063
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ ↑I ∩ {y | y i ≤ x}
h₃ : x < y i
H : ↑J = ↑I ∩ {y | y i ≤ x}
⊢ False
Theorem: Matrix.map_map
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.6588
m : Type u_1
n : Type u_2
o : Type ?u.6597
m' : o → Type ?u.6602
n' : o → Type ?u.6607
R : Type ?u.6610
S : Type ?u.6613
α : Type v
β✝ : Type w
γ✝ : Type ?u.6620
M : Matrix m n α
β : Type u_3
γ : Type u_4
f : α → β
g : β → γ
⊢ map (map M f) g = map M (g ∘ f)

tactic: rfl
state_before: case a.h
l : Type ?u.6588
m : Type u_1
n : Type u_2
o : Type ?u.6597
m' : o → Type ?u.6602
n' : o → Type ?u.6607
R : Type ?u.6610
S : Type ?u.6613
α : Type v
β✝ : Type w
γ✝ : Type ?u.6620
M : Matrix m n α
β : Type u_3
γ : Type u_4
f : α → β
g : β → γ
i✝ : m
x✝ : n
⊢ map (map M f) g i✝ x✝ = map M (g ∘ f) i✝ x✝
Theorem: UniformOnFun.uniformContinuous_restrict
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: change _ ≤ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.63791
ι : Type ?u.63794
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
h : s ∈ 𝔖
⊢ UniformContinuous (↑UniformFun.ofFun ∘ restrict s ∘ ↑(toFun 𝔖))

tactic: simp only [UniformOnFun.uniformSpace, map_le_iff_le_comap, iInf_uniformity]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.63791
ι : Type ?u.63794
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
h : s ∈ 𝔖
⊢ map
      (fun x =>
        ((↑UniformFun.ofFun ∘ restrict s ∘ ↑(toFun 𝔖)) x.fst, (↑UniformFun.ofFun ∘ restrict s ∘ ↑(toFun 𝔖)) x.snd))
      (𝓤 (α →ᵤ[𝔖] β)) ≤
    𝓤 (↑s →ᵤ β)

tactic: exact iInf₂_le s h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.63791
ι : Type ?u.63794
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
h : s ∈ 𝔖
⊢ (⨅ (i : Set α) (_ : i ∈ 𝔖), 𝓤 (α →ᵤ[𝔖] β)) ≤
    comap
      (fun x =>
        ((↑UniformFun.ofFun ∘ restrict s ∘ ↑(toFun 𝔖)) x.fst, (↑UniformFun.ofFun ∘ restrict s ∘ ↑(toFun 𝔖)) x.snd))
      (𝓤 (↑s →ᵤ β))
Theorem: Nat.dvd_of_mem_factors
File: Mathlib/Data/Nat/Factors.lean

tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: n p : ℕ
h : p ∈ factors n
⊢ p ∣ n

tactic: exact dvd_zero p
state_before: case inl
p : ℕ
h : p ∈ factors 0
⊢ p ∣ 0

tactic: rwa [← mem_factors_iff_dvd hn.ne' (prime_of_mem_factors h)]
state_before: case inr
n p : ℕ
h : p ∈ factors n
hn : n > 0
⊢ p ∣ n