tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.neighborSet_union_compl_neighborSet_eq
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext w
state_before: ι : Sort ?u.140009
𝕜 : Type ?u.140012
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
G : SimpleGraph V
v : V
⊢ neighborSet G v ∪ neighborSet (Gᶜ) v = {v}ᶜ

tactic: have h := @ne_of_adj _ G
state_before: case h
ι : Sort ?u.140009
𝕜 : Type ?u.140012
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
⊢ w ∈ neighborSet G v ∪ neighborSet (Gᶜ) v ↔ w ∈ {v}ᶜ

tactic: simp_rw [Set.mem_union, mem_neighborSet, compl_adj, Set.mem_compl_iff, Set.mem_singleton_iff]
state_before: case h
ι : Sort ?u.140009
𝕜 : Type ?u.140012
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, Adj G a b → a ≠ b
⊢ w ∈ neighborSet G v ∪ neighborSet (Gᶜ) v ↔ w ∈ {v}ᶜ

tactic: tauto
state_before: case h
ι : Sort ?u.140009
𝕜 : Type ?u.140012
V : Type u
W : Type v
X : Type w
G✝ : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : ∀ {a b : V}, Adj G a b → a ≠ b
⊢ Adj G v w ∨ v ≠ w ∧ ¬Adj G v w ↔ ¬w = v
Theorem: AlgEquiv.arrowCongr_comp
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: ext
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₁'
e₂ : A₂ ≃ₐ[R] A₂'
e₃ : A₃ ≃ₐ[R] A₃'
f : A₁ →ₐ[R] A₂
g : A₂ →ₐ[R] A₃
⊢ ↑(arrowCongr e₁ e₃) (AlgHom.comp g f) = AlgHom.comp (↑(arrowCongr e₂ e₃) g) (↑(arrowCongr e₁ e₂) f)

tactic: simp only [arrowCongr, Equiv.coe_fn_mk, AlgHom.comp_apply]
state_before: case H
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₁'
e₂ : A₂ ≃ₐ[R] A₂'
e₃ : A₃ ≃ₐ[R] A₃'
f : A₁ →ₐ[R] A₂
g : A₂ →ₐ[R] A₃
x✝ : A₁'
⊢ ↑(↑(arrowCongr e₁ e₃) (AlgHom.comp g f)) x✝ = ↑(AlgHom.comp (↑(arrowCongr e₂ e₃) g) (↑(arrowCongr e₁ e₂) f)) x✝

tactic: congr
state_before: case H
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₁'
e₂ : A₂ ≃ₐ[R] A₂'
e₃ : A₃ ≃ₐ[R] A₃'
f : A₁ →ₐ[R] A₂
g : A₂ →ₐ[R] A₃
x✝ : A₁'
⊢ ↑↑e₃ (↑g (↑f (↑↑(symm e₁) x✝))) = ↑↑e₃ (↑g (↑↑(symm e₂) (↑↑e₂ (↑f (↑↑(symm e₁) x✝)))))

tactic: exact (e₂.symm_apply_apply _).symm
state_before: case H.h.e_6.h.h.e_6.h
R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝¹² : CommSemiring R
inst✝¹¹ : Semiring A₁
inst✝¹⁰ : Semiring A₂
inst✝⁹ : Semiring A₃
inst✝⁸ : Algebra R A₁
inst✝⁷ : Algebra R A₂
inst✝⁶ : Algebra R A₃
e : A₁ ≃ₐ[R] A₂
A₁' : Type u_1
A₂' : Type u_2
A₃' : Type u_3
inst✝⁵ : Semiring A₁'
inst✝⁴ : Semiring A₂'
inst✝³ : Semiring A₃'
inst✝² : Algebra R A₁'
inst✝¹ : Algebra R A₂'
inst✝ : Algebra R A₃'
e₁ : A₁ ≃ₐ[R] A₁'
e₂ : A₂ ≃ₐ[R] A₂'
e₃ : A₃ ≃ₐ[R] A₃'
f : A₁ →ₐ[R] A₂
g : A₂ →ₐ[R] A₃
x✝ : A₁'
⊢ ↑f (↑↑(symm e₁) x✝) = ↑↑(symm e₂) (↑↑e₂ (↑f (↑↑(symm e₁) x✝)))
Theorem: CategoryTheory.isConnected_of_equivalent
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: infer_instance
state_before: J : Type u₁
inst✝³ : Category J
K✝ : Type u₂
inst✝² : Category K✝
K : Type u₁
inst✝¹ : Category K
e : J ≌ K
inst✝ : IsConnected J
⊢ Nonempty J
Theorem: Odd.pow_neg
File: Mathlib/Algebra/Parity.lean

tactic: cases' hn with k hk
state_before: F : Type ?u.108547
α : Type ?u.108550
β : Type ?u.108553
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
hn : Odd n
ha : a < 0
⊢ a ^ n < 0

tactic: simpa only [hk, two_mul] using pow_bit1_neg_iff.mpr ha
state_before: case intro
F : Type ?u.108547
α : Type ?u.108550
β : Type ?u.108553
R : Type u_1
inst✝ : LinearOrderedRing R
a : R
n : ℕ
ha : a < 0
k : ℕ
hk : n = 2 * k + 1
⊢ a ^ n < 0
Theorem: Matrix.Fin.circulant_ite
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective]
state_before: α✝ : Type ?u.59587
β : Type ?u.59590
m : Type ?u.59593
n : Type ?u.59596
R : Type ?u.59599
α : Type u_1
inst✝¹ : Zero α
inst✝ : One α
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = 1

tactic: rw [← circulant_single_one]
state_before: α✝ : Type ?u.59587
β : Type ?u.59590
m : Type ?u.59593
n✝ : Type ?u.59596
R : Type ?u.59599
α : Type u_1
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = 1

tactic: congr with j
state_before: α✝ : Type ?u.59587
β : Type ?u.59590
m : Type ?u.59593
n✝ : Type ?u.59596
R : Type ?u.59599
α : Type u_1
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
⊢ (circulant fun i => if ↑i = 0 then 1 else 0) = circulant (Pi.single 0 1)

tactic: simp [Pi.single_apply, Fin.ext_iff]
state_before: case a.h
α✝ : Type ?u.59587
β : Type ?u.59590
m : Type ?u.59593
n✝ : Type ?u.59596
R : Type ?u.59599
α : Type u_1
inst✝¹ : Zero α
inst✝ : One α
n : ℕ
j x✝ : Fin (n + 1)
⊢ circulant (fun i => if ↑i = 0 then 1 else 0) j x✝ = circulant (Pi.single 0 1) j x✝
Theorem: Int.card_Ioc_of_le
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_Ioc, toNat_sub_of_le h]
state_before: a b : ℤ
h : a ≤ b
⊢ ↑(card (Ioc a b)) = b - a
Theorem: neg_smul
File: Mathlib/Algebra/Module/Basic.lean

tactic: rw [← add_smul, add_left_neg, zero_smul]
state_before: α : Type ?u.98570
R : Type u_2
k : Type ?u.98576
S : Type ?u.98579
M : Type u_1
M₂ : Type ?u.98585
M₃ : Type ?u.98588
ι : Type ?u.98591
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
r s : R
x y : M
⊢ -r • x + r • x = 0
Theorem: Nat.Prime.pow_eq_iff
File: Mathlib/Data/Nat/Prime.lean

tactic: refine' ⟨fun h => _, fun h => by rw [h.1, h.2, pow_one]⟩
state_before: p a k : ℕ
hp : Prime p
⊢ a ^ k = p ↔ a = p ∧ k = 1

tactic: rw [← h] at hp
state_before: p a k : ℕ
hp : Prime p
h : a ^ k = p
⊢ a = p ∧ k = 1

tactic: rw [← h, hp.eq_one_of_pow, eq_self_iff_true, and_true_iff, pow_one]
state_before: p a k : ℕ
hp : Prime (a ^ k)
h : a ^ k = p
⊢ a = p ∧ k = 1

tactic: rw [h.1, h.2, pow_one]
state_before: p a k : ℕ
hp : Prime p
h : a = p ∧ k = 1
⊢ a ^ k = p
Theorem: equicontinuousAt_iff_range
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [← comp_rangeSplitting F]
state_before: ι : Type u_1
κ : Type ?u.31450
X : Type u_2
Y : Type ?u.31456
Z : Type ?u.31459
α : Type u_3
β : Type ?u.31465
γ : Type ?u.31468
𝓕 : Type ?u.31471
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
x₀ : X
h : EquicontinuousAt F x₀
⊢ EquicontinuousAt Subtype.val x₀

tactic: exact h.comp _
state_before: ι : Type u_1
κ : Type ?u.31450
X : Type u_2
Y : Type ?u.31456
Z : Type ?u.31459
α : Type u_3
β : Type ?u.31465
γ : Type ?u.31468
𝓕 : Type ?u.31471
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
x₀ : X
h : EquicontinuousAt F x₀
⊢ EquicontinuousAt (F ∘ rangeSplitting F) x₀
Theorem: Nat.bit0_eq_zero
File: Mathlib/Data/Nat/Bits.lean

tactic: simp [h]
state_before: n✝ n : ℕ
h : n = 0
⊢ bit0 n = 0
Theorem: GeneralizedContinuedFraction.exists_conts_a_of_num
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simpa
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
A : K
nth_num_eq : numerators g n = A
⊢ ∃ conts, continuants g n = conts ∧ conts.a = A
Theorem: Polynomial.coeff_X_pow
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: simp only [one_mul, RingHom.map_one, ← coeff_C_mul_X_pow]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
k n : ℕ
⊢ coeff (X ^ k) n = if n = k then 1 else 0
Theorem: Polynomial.Monic.nextCoeff_mul
File: Mathlib/Data/Polynomial/Monic.lean

tactic: nontriviality
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
⊢ nextCoeff (p * q) = nextCoeff p + nextCoeff q

tactic: simp only [← coeff_one_reverse]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
✝ : Nontrivial R
⊢ nextCoeff (p * q) = nextCoeff p + nextCoeff q

tactic: rw [reverse_mul] <;>
  simp [coeff_mul, Nat.antidiagonal, hp.leadingCoeff, hq.leadingCoeff, add_comm,
    show Nat.succ 0 = 1 from rfl]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
hq : Monic q
✝ : Nontrivial R
⊢ coeff (reverse (p * q)) 1 = coeff (reverse p) 1 + coeff (reverse q) 1
Theorem: Complex.sinh_ofReal_im
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_sinh_ofReal_re, ofReal_im]
state_before: x✝ y : ℂ
x : ℝ
⊢ (sinh ↑x).im = 0
Theorem: Finset.Ioo_subset_Iio_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ioo_subset_Iio_self
state_before: ι : Type ?u.57885
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ioo a b ⊆ Iio b
Theorem: completeSpace_iff_isComplete_range
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [completeSpace_iff_isComplete_univ, ← isComplete_image_iff hf, image_univ]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformInducing f
⊢ CompleteSpace α ↔ IsComplete (range f)
Theorem: Equiv.swap_apply_self
File: Mathlib/Logic/Equiv/Basic.lean

tactic: rw [← Equiv.trans_apply, Equiv.swap_swap, Equiv.refl_apply]
state_before: α : Sort u_1
inst✝ : DecidableEq α
i j a : α
⊢ ↑(swap i j) (↑(swap i j) a) = a
Theorem: Int.add_emod_eq_add_emod_right
File: Std/Data/Int/DivMod.lean

tactic: rw [← emod_add_emod, ← emod_add_emod k, H]
state_before: m n k i : Int
H : m % n = k % n
⊢ (m + i) % n = (k + i) % n
Theorem: Nat.mod_le
File: src/lean/Init/Data/Nat/Div.lean

tactic: match Nat.lt_or_ge x y with
| Or.inl h₁ => rw [mod_eq_of_lt h₁]; apply Nat.le_refl
| Or.inr h₁ => match eq_zero_or_pos y with
  | Or.inl h₂ => rw [h₂, Nat.mod_zero x]; apply Nat.le_refl
  | Or.inr h₂ => exact Nat.le_trans (Nat.le_of_lt (mod_lt _ h₂)) h₁
state_before: x y : Nat
⊢ x % y ≤ x

tactic: rw [mod_eq_of_lt h₁]
state_before: x y : Nat
h₁ : x < y
⊢ x % y ≤ x

tactic: apply Nat.le_refl
state_before: x y : Nat
h₁ : x < y
⊢ x ≤ x

tactic: match eq_zero_or_pos y with
| Or.inl h₂ => rw [h₂, Nat.mod_zero x]; apply Nat.le_refl
| Or.inr h₂ => exact Nat.le_trans (Nat.le_of_lt (mod_lt _ h₂)) h₁
state_before: x y : Nat
h₁ : x ≥ y
⊢ x % y ≤ x

tactic: rw [h₂, Nat.mod_zero x]
state_before: x y : Nat
h₁ : x ≥ y
h₂ : y = 0
⊢ x % y ≤ x

tactic: apply Nat.le_refl
state_before: x y : Nat
h₁ : x ≥ y
h₂ : y = 0
⊢ x ≤ x

tactic: exact Nat.le_trans (Nat.le_of_lt (mod_lt _ h₂)) h₁
state_before: x y : Nat
h₁ : x ≥ y
h₂ : y > 0
⊢ x % y ≤ x
Theorem: closure_Ioi'
File: Mathlib/Topology/Order/Basic.lean

tactic: apply Subset.antisymm
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
h : Set.Nonempty (Ioi a)
⊢ closure (Ioi a) = Ici a

tactic: exact closure_minimal Ioi_subset_Ici_self isClosed_Ici
state_before: case h₁
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
h : Set.Nonempty (Ioi a)
⊢ closure (Ioi a) ⊆ Ici a

tactic: rw [← diff_subset_closure_iff, Ici_diff_Ioi_same, singleton_subset_iff]
state_before: case h₂
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
h : Set.Nonempty (Ioi a)
⊢ Ici a ⊆ closure (Ioi a)

tactic: exact isGLB_Ioi.mem_closure h
state_before: case h₂
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
h : Set.Nonempty (Ioi a)
⊢ a ∈ closure (Ioi a)
Theorem: cardinal_lt_aleph0_of_finiteDimensional
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: letI : IsNoetherian K V := IsNoetherian.iff_fg.2 inferInstance
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
⊢ (#V) < ℵ₀

tactic: rw [cardinal_mk_eq_cardinal_mk_field_pow_rank K V]
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
this : IsNoetherian K V := Iff.mpr IsNoetherian.iff_fg inferInstance
⊢ (#V) < ℵ₀

tactic: exact Cardinal.power_lt_aleph0 (Cardinal.lt_aleph0_of_finite K) (IsNoetherian.rank_lt_aleph0 K V)
state_before: K✝ : Type u
V✝ : Type v
K V : Type u
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : _root_.Finite K
inst✝ : FiniteDimensional K V
this : IsNoetherian K V := Iff.mpr IsNoetherian.iff_fg inferInstance
⊢ (#K) ^ Module.rank K V < ℵ₀
Theorem: HasDerivAt.inv
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : 𝕜 → 𝕜
h : E → 𝕜
c' : 𝕜
z : E
S : Set E
hc : HasDerivAt c c' x
hx : c x ≠ 0
⊢ HasDerivAt (fun y => (c y)⁻¹) (-c' / c x ^ 2) x

tactic: exact hc.inv hx
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : 𝕜 → 𝕜
h : E → 𝕜
c' : 𝕜
z : E
S : Set E
hc : HasDerivWithinAt c c' univ x
hx : c x ≠ 0
⊢ HasDerivWithinAt (fun y => (c y)⁻¹) (-c' / c x ^ 2) univ x
Theorem: Finset.mem_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

tactic: simp [nonMemberSubfamily]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
⊢ s ∈ nonMemberSubfamily a 𝒜 ↔ s ∈ 𝒜 ∧ ¬a ∈ s
Theorem: Filter.push_pull'
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [Filter.push_pull, inf_comm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.287461
ι : Sort x
f : α → β
F : Filter α
G : Filter β
⊢ map f (comap f G ⊓ F) = G ⊓ map f F
Theorem: GCDMonoid.prime_of_irreducible
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: cases' gcd_dvd_left x a with y hy
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
⊢ x ∣ a ∨ x ∣ b

tactic: cases' hi.isUnit_or_isUnit hy with hu hu
state_before: case intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
⊢ x ∣ a ∨ x ∣ b

tactic: right
state_before: case intro.inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ x ∣ a ∨ x ∣ b

tactic: trans gcd (x * b) (a * b)
state_before: case intro.inl.h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ x ∣ b

tactic: apply dvd_gcd (dvd_mul_right x b) h
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ x ∣ gcd (x * b) (a * b)

α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ gcd (x * b) (a * b) ∣ b

tactic: rw [(gcd_mul_right' b x a).dvd_iff_dvd_left]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ gcd (x * b) (a * b) ∣ b

tactic: exact (associated_unit_mul_left _ _ hu).dvd
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit (gcd x a)
⊢ gcd x a * b ∣ b

tactic: left
state_before: case intro.inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit y
⊢ x ∣ a ∨ x ∣ b

tactic: rw [hy]
state_before: case intro.inr.h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit y
⊢ x ∣ a

tactic: exact dvd_trans (associated_mul_unit_left _ _ hu).dvd (gcd_dvd_right x a)
state_before: case intro.inr.h
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x : α
hi : Irreducible x
a b : α
h : x ∣ a * b
y : α
hy : x = gcd x a * y
hu : IsUnit y
⊢ gcd x a * y ∣ a
Theorem: Filter.bot_coprod
File: Mathlib/Order/Filter/Prod.lean

tactic: simp [Filter.coprod]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.57284
δ : Type ?u.57287
ι : Sort ?u.57290
f : Filter α
g l : Filter β
⊢ Filter.coprod ⊥ l = comap Prod.snd l
Theorem: IsEvenlyCovered.toTrivialization_apply
File: Mathlib/Topology/Covering.lean

tactic: rwa [he, e.mem_target, e.coe_fst (e.mem_source.mpr h)]
state_before: E : Type u_2
X : Type u_3
inst✝² : TopologicalSpace E
inst✝¹ : TopologicalSpace X
f : E → X
s : Set X
x : E
I : Type u_1
inst✝ : TopologicalSpace I
h✝ : IsEvenlyCovered f (f x) I
e : Trivialization I f := Classical.choose (_ : ∃ t, f x ∈ t.baseSet)
h : f x ∈ (Classical.choose (_ : ∃ t, f x ∈ t.baseSet)).baseSet := Classical.choose_spec h✝.right
he : (f x, (↑e x).snd) = ↑e x := Trivialization.mk_proj_snd' e h
⊢ (f x, (↑e x).snd) ∈ e.target
Theorem: directedOn_image
File: Mathlib/Order/Directed.lean

tactic: simp only [DirectedOn, Set.mem_image, exists_exists_and_eq_and, forall_exists_index, and_imp,
  forall_apply_eq_imp_iff₂, Order.Preimage]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
s : Set β
f : β → α
⊢ DirectedOn r (f '' s) ↔ DirectedOn (f ⁻¹'o r) s
Theorem: Finset.eq_empty_iff_forall_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: rintro rfl x
state_before: α : Type u_1
β : Type ?u.20009
γ : Type ?u.20012
s✝ s : Finset α
⊢ s = ∅ → ∀ (x : α), ¬x ∈ s

tactic: apply not_mem_empty
state_before: α : Type u_1
β : Type ?u.20009
γ : Type ?u.20012
s : Finset α
x : α
⊢ ¬x ∈ ∅
Theorem: Subgroup.map_le_map_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [map_le_iff_le_comap, comap_map_eq]
state_before: G : Type u_1
G' : Type ?u.586626
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.586635
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
H K : Subgroup G
⊢ map f H ≤ map f K ↔ H ≤ K ⊔ ker f
Theorem: EuclideanGeometry.reflection_mem_of_le_of_mem
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [reflection_apply]
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s₁ s₂ : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s₁ }
inst✝ : CompleteSpace { x // x ∈ direction s₁ }
hle : s₁ ≤ s₂
p : P
hp : p ∈ s₂
⊢ ↑(reflection s₁) p ∈ s₂

tactic: have ho : ↑(orthogonalProjection s₁ p) ∈ s₂ := hle (orthogonalProjection_mem p)
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s₁ s₂ : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s₁ }
inst✝ : CompleteSpace { x // x ∈ direction s₁ }
hle : s₁ ≤ s₂
p : P
hp : p ∈ s₂
⊢ ↑(↑(orthogonalProjection s₁) p) -ᵥ p +ᵥ ↑(↑(orthogonalProjection s₁) p) ∈ s₂

tactic: exact vadd_mem_of_mem_direction (vsub_mem_direction ho hp) ho
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s₁ s₂ : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s₁ }
inst✝ : CompleteSpace { x // x ∈ direction s₁ }
hle : s₁ ≤ s₂
p : P
hp : p ∈ s₂
ho : ↑(↑(orthogonalProjection s₁) p) ∈ s₂
⊢ ↑(↑(orthogonalProjection s₁) p) -ᵥ p +ᵥ ↑(↑(orthogonalProjection s₁) p) ∈ s₂
Theorem: Sym2.toRel_symmetric
File: Mathlib/Data/Sym/Sym2.lean

tactic: simp [eq_swap]
state_before: α : Type u_1
β : Type ?u.47798
γ : Type ?u.47801
r : α → α → Prop
s : Set (Sym2 α)
x y : α
⊢ ToRel s x y → ToRel s y x
Theorem: InnerProductGeometry.cos_angle_add_mul_norm_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [cos_angle_add_of_inner_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ Real.cos (angle x (x + y)) * ‖x + y‖ = ‖x‖

tactic: by_cases hxy : ‖x + y‖ = 0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ ‖x‖ / ‖x + y‖ * ‖x + y‖ = ‖x‖

tactic: have h' := norm_add_sq_eq_norm_sq_add_norm_sq_real h
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hxy : ‖x + y‖ = 0
⊢ ‖x‖ / ‖x + y‖ * ‖x + y‖ = ‖x‖

tactic: rw [hxy, MulZeroClass.zero_mul, eq_comm,
  add_eq_zero_iff' (mul_self_nonneg ‖x‖) (mul_self_nonneg ‖y‖), mul_self_eq_zero] at h'
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hxy : ‖x + y‖ = 0
h' : ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖
⊢ ‖x‖ / ‖x + y‖ * ‖x + y‖ = ‖x‖

tactic: simp [h'.1]
state_before: case pos
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hxy : ‖x + y‖ = 0
h' : ‖x‖ = 0 ∧ ‖y‖ * ‖y‖ = 0
⊢ ‖x‖ / ‖x + y‖ * ‖x + y‖ = ‖x‖

tactic: exact div_mul_cancel _ hxy
state_before: case neg
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
hxy : ¬‖x + y‖ = 0
⊢ ‖x‖ / ‖x + y‖ * ‖x + y‖ = ‖x‖