tasksource/leandojo huggingface dataset:
Theorem: Set.Nonempty.zero_div
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simpa [mem_div] using hs
state_before: F : Type ?u.149962
α : Type u_1
β : Type ?u.149968
γ : Type ?u.149971
inst✝ : GroupWithZero α
s t : Set α
hs : Set.Nonempty s
⊢ 0 ⊆ 0 / s
Theorem: DivisorChain.card_subset_divisors_le_length_of_chain
File: Mathlib/RingTheory/ChainOfDivisors.lean

tactic: classical
  have mem_image : ∀ r : Associates M, r ≤ q → r ∈ Finset.univ.image c := by
    intro r hr
    obtain ⟨i, hi⟩ := h₂.1 hr
    exact Finset.mem_image.2 ⟨i, Finset.mem_univ _, hi.symm⟩
  rw [← Finset.card_fin (n + 1)]
  exact (Finset.card_le_of_subset fun x hx => mem_image x <| hm x hx).trans Finset.card_image_le
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
⊢ Finset.card m ≤ n + 1

tactic: have mem_image : ∀ r : Associates M, r ≤ q → r ∈ Finset.univ.image c := by
  intro r hr
  obtain ⟨i, hi⟩ := h₂.1 hr
  exact Finset.mem_image.2 ⟨i, Finset.mem_univ _, hi.symm⟩
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
⊢ Finset.card m ≤ n + 1

tactic: rw [← Finset.card_fin (n + 1)]
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
mem_image : ∀ (r : Associates M), r ≤ q → r ∈ Finset.image c Finset.univ
⊢ Finset.card m ≤ n + 1

tactic: exact (Finset.card_le_of_subset fun x hx => mem_image x <| hm x hx).trans Finset.card_image_le
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
mem_image : ∀ (r : Associates M), r ≤ q → r ∈ Finset.image c Finset.univ
⊢ Finset.card m ≤ Finset.card Finset.univ

tactic: intro r hr
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
⊢ ∀ (r : Associates M), r ≤ q → r ∈ Finset.image c Finset.univ

tactic: obtain ⟨i, hi⟩ := h₂.1 hr
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
r : Associates M
hr : r ≤ q
⊢ r ∈ Finset.image c Finset.univ

tactic: exact Finset.mem_image.2 ⟨i, Finset.mem_univ _, hi.symm⟩
state_before: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
m : Finset (Associates M)
hm : ∀ (r : Associates M), r ∈ m → r ≤ q
r : Associates M
hr : r ≤ q
i : Fin (n + 1)
hi : r = c i
⊢ r ∈ Finset.image c Finset.univ
Theorem: UpperSet.Ici_iSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [mem_Ici_iff, mem_iSup_iff, iSup_le_iff]
state_before: α : Type u_1
β : Type ?u.115407
γ : Type ?u.115410
ι : Sort u_2
κ : ι → Sort ?u.115418
inst✝ : CompleteLattice α
f : ι → α
c : α
⊢ c ∈ Ici (⨆ (i : ι), f i) ↔ c ∈ ⨆ (i : ι), Ici (f i)
Theorem: ManyOneDegree.le_antisymm
File: Mathlib/Computability/Reduce.lean

tactic: induction d₁ using ManyOneDegree.ind_on
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₁ d₂ : ManyOneDegree
⊢ d₁ ≤ d₂ → d₂ ≤ d₁ → d₁ = d₂

tactic: induction d₂ using ManyOneDegree.ind_on
state_before: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₂ : ManyOneDegree
p✝ : Set ℕ
⊢ of p✝ ≤ d₂ → d₂ ≤ of p✝ → of p✝ = d₂

tactic: intro hp hq
state_before: case h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝¹ p✝ : Set ℕ
⊢ of p✝¹ ≤ of p✝ → of p✝ ≤ of p✝¹ → of p✝¹ = of p✝

tactic: simp_all only [ManyOneEquiv, of_le_of, of_eq_of, true_and_iff]
state_before: case h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝¹ p✝ : Set ℕ
hp : of p✝¹ ≤ of p✝
hq : of p✝ ≤ of p✝¹
⊢ of p✝¹ = of p✝
Theorem: inv_eq_one_divp'
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [one_div, one_divp]
state_before: α : Type u
inst✝ : Monoid α
a b c : α
u : αˣ
⊢ ↑(1 / u) = 1 /ₚ u
Theorem: Nat.factorial_lt
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: refine' ⟨fun h => not_le.mp fun hmn => not_le_of_lt h (factorial_le hmn), fun h => _⟩
state_before: m n : ℕ
hn : 0 < n
⊢ n ! < m ! ↔ n < m

tactic: have : ∀ {n}, 0 < n → n ! < n.succ ! := by
  intro k hk
  rw [factorial_succ, succ_mul, lt_add_iff_pos_left]
  exact mul_pos hk k.factorial_pos
state_before: m n : ℕ
hn : 0 < n
h : n < m
⊢ n ! < m !

tactic: induction' h with k hnk ih generalizing hn
state_before: m n : ℕ
hn : 0 < n
h : n < m
this : ∀ {n : ℕ}, 0 < n → n ! < (succ n)!
⊢ n ! < m !

tactic: intro k hk
state_before: m n : ℕ
hn : 0 < n
h : n < m
⊢ ∀ {n : ℕ}, 0 < n → n ! < (succ n)!

tactic: rw [factorial_succ, succ_mul, lt_add_iff_pos_left]
state_before: m n : ℕ
hn : 0 < n
h : n < m
k : ℕ
hk : 0 < k
⊢ k ! < (succ k)!

tactic: exact mul_pos hk k.factorial_pos
state_before: m n : ℕ
hn : 0 < n
h : n < m
k : ℕ
hk : 0 < k
⊢ 0 < k * k !

tactic: exact this hn
state_before: case refl
m n : ℕ
hn✝ : 0 < n
this : ∀ {n : ℕ}, 0 < n → n ! < (succ n)!
hn : 0 < n
⊢ n ! < (succ n)!

tactic: exact (ih hn).trans (this <| hn.trans <| lt_of_succ_le hnk)
state_before: case step
m n : ℕ
hn✝ : 0 < n
this : ∀ {n : ℕ}, 0 < n → n ! < (succ n)!
k : ℕ
hnk : Nat.le (succ n) k
ih : 0 < n → n ! < k !
hn : 0 < n
⊢ n ! < (succ k)!
Theorem: minpoly.not_isUnit
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: haveI : Nontrivial A := (algebraMap A B).domain_nontrivial
state_before: A : Type u_2
B : Type u_1
B' : Type ?u.29630
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
⊢ ¬IsUnit (minpoly A x)

tactic: by_cases hx : IsIntegral A x
state_before: A : Type u_2
B : Type u_1
B' : Type ?u.29630
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
this : Nontrivial A
⊢ ¬IsUnit (minpoly A x)

tactic: exact mt (monic hx).eq_one_of_isUnit (ne_one A x)
state_before: case pos
A : Type u_2
B : Type u_1
B' : Type ?u.29630
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
this : Nontrivial A
hx : IsIntegral A x
⊢ ¬IsUnit (minpoly A x)

tactic: rw [eq_zero hx]
state_before: case neg
A : Type u_2
B : Type u_1
B' : Type ?u.29630
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
this : Nontrivial A
hx : ¬IsIntegral A x
⊢ ¬IsUnit (minpoly A x)

tactic: exact not_isUnit_zero
state_before: case neg
A : Type u_2
B : Type u_1
B' : Type ?u.29630
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
this : Nontrivial A
hx : ¬IsIntegral A x
⊢ ¬IsUnit 0
Theorem: Cardinal.mul_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← Nat.cast_mul]
state_before: α β : Type u
a b : Cardinal
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑m * ↑n < ℵ₀

tactic: apply nat_lt_aleph0
state_before: α β : Type u
a b : Cardinal
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑(m * n) < ℵ₀
Theorem: lowerClosure_singleton
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.158776
γ : Type ?u.158779
ι : Sort ?u.158782
κ : ι → Sort ?u.158787
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a : α
⊢ lowerClosure {a} = LowerSet.Iic a

tactic: simp
state_before: case a.h
α : Type u_1
β : Type ?u.158776
γ : Type ?u.158779
ι : Sort ?u.158782
κ : ι → Sort ?u.158787
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x a x✝ : α
⊢ x✝ ∈ ↑(lowerClosure {a}) ↔ x✝ ∈ ↑(LowerSet.Iic a)
Theorem: Sym2.mk''_prod_swap_eq
File: Mathlib/Data/Sym/Sym2.lean

tactic: cases p
state_before: α : Type u_1
β : Type ?u.4166
γ : Type ?u.4169
p : α × α
⊢ Quotient.mk (Rel.setoid α) (Prod.swap p) = Quotient.mk (Rel.setoid α) p

tactic: exact eq_swap
state_before: case mk
α : Type u_1
β : Type ?u.4166
γ : Type ?u.4169
fst✝ snd✝ : α
⊢ Quotient.mk (Rel.setoid α) (Prod.swap (fst✝, snd✝)) = Quotient.mk (Rel.setoid α) (fst✝, snd✝)
Theorem: Matrix.Fin.circulant_injective
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective]
state_before: α : Type u_1
β : Type ?u.1682
m : Type ?u.1685
n : Type ?u.1688
R : Type ?u.1691
⊢ Injective fun v => circulant v
Theorem: Setoid.comap_eq
File: Mathlib/Data/Setoid/Basic.lean

tactic: rw [Quotient.eq]
state_before: α : Type u_2
β : Type u_1
r✝ : Setoid α
f✝ f : α → β
r : Setoid β
x y : α
⊢ Setoid.r x y ↔ Quotient.mk r (f x) = Quotient.mk r (f y)

tactic: rfl
state_before: α : Type u_2
β : Type u_1
r✝ : Setoid α
f✝ f : α → β
r : Setoid β
x y : α
⊢ Setoid.r x y ↔ f x ≈ f y
Theorem: IsOpen.mem_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [← subset_interior_iff_mem_nhdsSet, hU.interior_eq]
state_before: α : Type u_1
β : Type ?u.11087
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t s₁ s₂ t₁ t₂ : Set α
x : α
hU : IsOpen s
⊢ s ∈ 𝓝ˢ t ↔ t ⊆ s
Theorem: Fin.val_cast_of_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← ofNat_eq_val]
state_before: n✝ m n : ℕ
inst✝ : NeZero n
a : ℕ
h : a < n
⊢ ↑↑a = a

tactic: exact Nat.mod_eq_of_lt h
state_before: n✝ m n : ℕ
inst✝ : NeZero n
a : ℕ
h : a < n
⊢ ↑(ofNat'' a) = a
Theorem: Finset.image₂_nonempty_iff
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [← coe_nonempty, coe_image₂]
state_before: α : Type u_2
α' : Type ?u.21579
β : Type u_3
β' : Type ?u.21585
γ : Type u_1
γ' : Type ?u.21591
δ : Type ?u.21594
δ' : Type ?u.21597
ε : Type ?u.21600
ε' : Type ?u.21603
ζ : Type ?u.21606
ζ' : Type ?u.21609
ν : Type ?u.21612
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ Finset.Nonempty (image₂ f s t) ↔ Finset.Nonempty s ∧ Finset.Nonempty t

tactic: exact image2_nonempty_iff
state_before: α : Type u_2
α' : Type ?u.21579
β : Type u_3
β' : Type ?u.21585
γ : Type u_1
γ' : Type ?u.21591
δ : Type ?u.21594
δ' : Type ?u.21597
ε : Type ?u.21600
ε' : Type ?u.21603
ζ : Type ?u.21606
ζ' : Type ?u.21609
ν : Type ?u.21612
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ Set.Nonempty (image2 f ↑s ↑t) ↔ Finset.Nonempty s ∧ Finset.Nonempty t
Theorem: rank_matrix
File: Mathlib/LinearAlgebra/FreeModule/Rank.lean

tactic: cases nonempty_fintype m
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m : Type v
n : Type w
inst✝¹ : Finite m
inst✝ : Finite n
⊢ Module.rank R (Matrix m n R) = Cardinal.lift (#m) * Cardinal.lift (#n)

tactic: cases nonempty_fintype n
state_before: case intro
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m : Type v
n : Type w
inst✝¹ : Finite m
inst✝ : Finite n
val✝ : Fintype m
⊢ Module.rank R (Matrix m n R) = Cardinal.lift (#m) * Cardinal.lift (#n)

tactic: have h := (Matrix.stdBasis R m n).mk_eq_rank
state_before: case intro.intro
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m : Type v
n : Type w
inst✝¹ : Finite m
inst✝ : Finite n
val✝¹ : Fintype m
val✝ : Fintype n
⊢ Module.rank R (Matrix m n R) = Cardinal.lift (#m) * Cardinal.lift (#n)

tactic: rw [← lift_lift.{max v w u, max v w}, lift_inj] at h
state_before: case intro.intro
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m : Type v
n : Type w
inst✝¹ : Finite m
inst✝ : Finite n
val✝¹ : Fintype m
val✝ : Fintype n
h : Cardinal.lift (#m × n) = Cardinal.lift (Module.rank R (Matrix m n R))
⊢ Module.rank R (Matrix m n R) = Cardinal.lift (#m) * Cardinal.lift (#n)

tactic: simpa using h.symm
state_before: case intro.intro
R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m : Type v
n : Type w
inst✝¹ : Finite m
inst✝ : Finite n
val✝¹ : Fintype m
val✝ : Fintype n
h : Cardinal.lift (#m × n) = Module.rank R (Matrix m n R)
⊢ Module.rank R (Matrix m n R) = Cardinal.lift (#m) * Cardinal.lift (#n)
Theorem: Nat.fib_two_mul_add_one
File: Mathlib/Data/Nat/Fib.lean

tactic: rw [two_mul, fib_add]
state_before: n : ℕ
⊢ fib (2 * n + 1) = fib (n + 1) ^ 2 + fib n ^ 2

tactic: ring
state_before: n : ℕ
⊢ fib n * fib n + fib (n + 1) * fib (n + 1) = fib (n + 1) ^ 2 + fib n ^ 2
Theorem: Cardinal.lift_lt_nat_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_natCast.{v,u}, lift_lt]
state_before: α β : Type u
a : Cardinal
n : ℕ
⊢ lift a < ↑n ↔ a < ↑n
Theorem: MvPolynomial.eval₂_C
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [C_apply, eval₂_monomial, prod_zero_index, mul_one]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
a : R
⊢ eval₂ f g (↑C a) = ↑f a
Theorem: le_mul_inv_of_mul_le
File: Mathlib/Algebra/Order/WithZero.lean

tactic: simpa [h] using hab
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : c ≠ 0
hab : a * c ≤ b
⊢ a * c ≤ b * c⁻¹ * c
Theorem: Metric.mem_sphere_comm
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [mem_sphere', mem_sphere]
state_before: α : Type u
β : Type v
X : Type ?u.38896
ι : Type ?u.38899
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ x ∈ sphere y ε ↔ y ∈ sphere x ε
Theorem: Order.Ideal.IsProper.not_mem_or_compl_not_mem
File: Mathlib/Order/Ideal.lean

tactic: have h : xᶜ ∈ I → x ∉ I := hI.not_mem_of_compl_mem
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
⊢ ¬x ∈ I ∨ ¬xᶜ ∈ I

tactic: tauto
state_before: P : Type u_1
inst✝ : BooleanAlgebra P
x : P
I : Ideal P
hI : IsProper I
h : xᶜ ∈ I → ¬x ∈ I
⊢ ¬x ∈ I ∨ ¬xᶜ ∈ I
Theorem: CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : IsIso f
⊢ (pushoutCoconeOfLeftIso f g).ι.app none = g
Theorem: Polynomial.eq_of_degree_sub_lt_of_eval_finset_eq
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← sub_eq_zero]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_fg_lt : degree (f - g) < ↑(Finset.card s)
eval_fg : ∀ (x : R), x ∈ s → eval x f = eval x g
⊢ f = g

tactic: refine' eq_zero_of_degree_lt_of_eval_finset_eq_zero _ degree_fg_lt _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_fg_lt : degree (f - g) < ↑(Finset.card s)
eval_fg : ∀ (x : R), x ∈ s → eval x f = eval x g
⊢ f - g = 0

tactic: simp_rw [eval_sub, sub_eq_zero]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_fg_lt : degree (f - g) < ↑(Finset.card s)
eval_fg : ∀ (x : R), x ∈ s → eval x f = eval x g
⊢ ∀ (x : R), x ∈ s → eval x (f - g) = 0

tactic: exact eval_fg
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
degree_fg_lt : degree (f - g) < ↑(Finset.card s)
eval_fg : ∀ (x : R), x ∈ s → eval x f = eval x g
⊢ ∀ (x : R), x ∈ s → eval x f = eval x g
Theorem: tendsto_nhdsWithin_iff_subtype
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin_eq_map_subtype_coe h, tendsto_map'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.305005
δ : Type ?u.305008
inst✝ : TopologicalSpace α
s : Set α
a : α
h : a ∈ s
f : α → β
l : Filter β
⊢ Tendsto f (𝓝[s] a) l ↔ Tendsto (restrict s f) (𝓝 { val := a, property := h }) l

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.305005
δ : Type ?u.305008
inst✝ : TopologicalSpace α
s : Set α
a : α
h : a ∈ s
f : α → β
l : Filter β
⊢ Tendsto (f ∘ Subtype.val) (𝓝 { val := a, property := h }) l ↔ Tendsto (restrict s f) (𝓝 { val := a, property := h }) l
Theorem: CategoryTheory.Presieve.FamilyOfElements.Compatible.functorPullback
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: intro Z₁ Z₂ W g₁ g₂ f₁ f₂ h₁ h₂ eq
state_before: C : Type u₁
inst✝¹ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
D : Type u₂
inst✝ : Category D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : Compatible x
⊢ Compatible (FamilyOfElements.functorPullback F x)

tactic: exact h (F.map g₁) (F.map g₂) h₁ h₂ (by simp only [← F.map_comp, eq])
state_before: C : Type u₁
inst✝¹ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
D : Type u₂
inst✝ : Category D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : Compatible x
Z₁ Z₂ W : D
g₁ : W ⟶ Z₁
g₂ : W ⟶ Z₂
f₁ : Z₁ ⟶ Z
f₂ : Z₂ ⟶ Z
h₁ : Presieve.functorPullback F T f₁
h₂ : Presieve.functorPullback F T f₂
eq : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ (Functor.op F ⋙ P).map g₁.op (FamilyOfElements.functorPullback F x f₁ h₁) =
    (Functor.op F ⋙ P).map g₂.op (FamilyOfElements.functorPullback F x f₂ h₂)

tactic: simp only [← F.map_comp, eq]
state_before: C : Type u₁
inst✝¹ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
D : Type u₂
inst✝ : Category D
F : D ⥤ C
Z : D
T : Presieve (F.obj Z)
x : FamilyOfElements P T
h : Compatible x
Z₁ Z₂ W : D
g₁ : W ⟶ Z₁
g₂ : W ⟶ Z₂
f₁ : Z₁ ⟶ Z
f₂ : Z₂ ⟶ Z
h₁ : Presieve.functorPullback F T f₁
h₂ : Presieve.functorPullback F T f₂
eq : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ F.map g₁ ≫ F.map f₁ = F.map g₂ ≫ F.map f₂
Theorem: Polynomial.dvd_content_iff_C_dvd
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [C_dvd_iff_dvd_coeff]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
⊢ r ∣ content p ↔ ↑C r ∣ p

tactic: constructor
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
⊢ r ∣ content p ↔ ∀ (i : ℕ), r ∣ coeff p i

tactic: intro h i
state_before: case mp
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
⊢ r ∣ content p → ∀ (i : ℕ), r ∣ coeff p i

tactic: apply h.trans (content_dvd_coeff _)
state_before: case mp
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
h : r ∣ content p
i : ℕ
⊢ r ∣ coeff p i

tactic: intro h
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
⊢ (∀ (i : ℕ), r ∣ coeff p i) → r ∣ content p

tactic: rw [content, Finset.dvd_gcd_iff]
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
h : ∀ (i : ℕ), r ∣ coeff p i
⊢ r ∣ content p

tactic: intro i _
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
h : ∀ (i : ℕ), r ∣ coeff p i
⊢ ∀ (b : ℕ), b ∈ support p → r ∣ coeff p b

tactic: apply h i
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
r : R
h : ∀ (i : ℕ), r ∣ coeff p i
i : ℕ
a✝ : i ∈ support p
⊢ r ∣ coeff p i
Theorem: Nat.factorization_choose_eq_zero_of_lt
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: by_cases hnk : n < k
state_before: p n k : ℕ
h : n < p
⊢ ↑(factorization (choose n k)) p = 0

tactic: rw [choose_eq_factorial_div_factorial (le_of_not_lt hnk),
  factorization_div (factorial_mul_factorial_dvd_factorial (le_of_not_lt hnk)), Finsupp.coe_tsub,
  Pi.sub_apply, factorization_factorial_eq_zero_of_lt h, zero_tsub]
state_before: case neg
p n k : ℕ
h : n < p
hnk : ¬n < k
⊢ ↑(factorization (choose n k)) p = 0

tactic: simp [choose_eq_zero_of_lt hnk]
state_before: case pos
p n k : ℕ
h : n < p
hnk : n < k
⊢ ↑(factorization (choose n k)) p = 0
Theorem: SimpleGraph.Subgraph.IsMatching.support_eq_verts
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

tactic: refine M.support_subset_verts.antisymm fun v hv => ?_
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
⊢ support M = M.verts

tactic: obtain ⟨w, hvw, -⟩ := h hv
state_before: V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
v : V
hv : v ∈ M.verts
⊢ v ∈ support M

tactic: exact ⟨_, hvw⟩
state_before: case intro.intro
V : Type u
G : SimpleGraph V
M✝ M : Subgraph G
h : IsMatching M
v : V
hv : v ∈ M.verts
w : V
hvw : Adj M v w
⊢ v ∈ support M
Theorem: ENNReal.mul_left_strictMono
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift a to ℝ≥0 using hinf
state_before: α : Type ?u.160126
β : Type ?u.160129
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hinf : a ≠ ⊤
⊢ StrictMono fun x => a * x

tactic: rw [coe_ne_zero] at h0
state_before: case intro
α : Type ?u.160126
β : Type ?u.160129
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : ↑a ≠ 0
⊢ StrictMono fun x => ↑a * x

tactic: intro x y h
state_before: case intro
α : Type ?u.160126
β : Type ?u.160129
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
⊢ StrictMono fun x => ↑a * x

tactic: contrapose! h
state_before: case intro
α : Type ?u.160126
β : Type ?u.160129
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : x < y
⊢ (fun x => ↑a * x) x < (fun x => ↑a * x) y

tactic: simpa only [← mul_assoc, ← coe_mul, inv_mul_cancel h0, coe_one, one_mul]
  using mul_le_mul_left' h (↑a⁻¹)
state_before: case intro
α : Type ?u.160126
β : Type ?u.160129
b c d : ℝ≥0∞
r p q a : ℝ≥0
h0 : a ≠ 0
x y : ℝ≥0∞
h : ↑a * y ≤ ↑a * x
⊢ y ≤ x