tasksource/leandojo huggingface dataset:
Theorem: Dfinsupp.support_sup
File: Mathlib/Data/Dfinsupp/Order.lean

tactic: ext
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
⊢ support (f ⊔ g) = support f ∪ support g

tactic: simp only [Finset.mem_union, mem_support_iff, sup_apply, Ne.def, ← bot_eq_zero]
state_before: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ a✝ ∈ support (f ⊔ g) ↔ a✝ ∈ support f ∪ support g

tactic: rw [_root_.sup_eq_bot_iff, not_and_or]
state_before: case a
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → CanonicallyLinearOrderedAddMonoid (α i)
inst✝ : DecidableEq ι
f g : Π₀ (i : ι), α i
a✝ : ι
⊢ ¬↑f a✝ ⊔ ↑g a✝ = ⊥ ↔ ¬↑f a✝ = ⊥ ∨ ¬↑g a✝ = ⊥
Theorem: Int.neg_pos_of_neg
File: Std/Data/Int/Lemmas.lean

tactic: have : -0 < -a := Int.neg_lt_neg h
state_before: a : Int
h : a < 0
⊢ 0 < -a

tactic: rwa [Int.neg_zero] at this
state_before: a : Int
h : a < 0
this : -0 < -a
⊢ 0 < -a
Theorem: Equiv.Perm.SameCycle.trans
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [zpow_add, mul_apply, hi, hj]
state_before: ι : Type ?u.31228
α : Type u_1
β : Type ?u.31234
f g : Perm α
p : α → Prop
x y z : α
x✝¹ : SameCycle f x y
x✝ : SameCycle f y z
i : ℤ
hi : ↑(f ^ i) x = y
j : ℤ
hj : ↑(f ^ j) y = z
⊢ ↑(f ^ (j + i)) x = z
Theorem: PGame.neg_fuzzy_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg y, neg_fuzzy_neg_iff, neg_neg]
state_before: x y : PGame
⊢ -x ‖ y ↔ x ‖ -y
Theorem: Trivialization.isImage_preimage_prod
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: simp [e.coe_fst', hx]
state_before: ι : Type ?u.59757
B : Type u_1
F : Type u_2
E : B → Type ?u.59768
Z : Type u_3
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace F
proj : Z → B
inst✝² : TopologicalSpace Z
inst✝¹ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b : B
y : E b
B' : Type ?u.59856
inst✝ : TopologicalSpace B'
e : Trivialization F proj
s : Set B
x : Z
hx : x ∈ e.source
⊢ ↑e.toLocalHomeomorph x ∈ s ×ˢ univ ↔ x ∈ proj ⁻¹' s
Theorem: Complex.div_I
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [mul_assoc]
state_before: z : ℂ
⊢ -(z * I) * I = z
Theorem: minpoly.ne_one
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: intro h
state_before: A : Type u_2
B : Type u_1
B' : Type ?u.21842
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
⊢ minpoly A x ≠ 1

tactic: refine' (one_ne_zero : (1 : B) ≠ 0) _
state_before: A : Type u_2
B : Type u_1
B' : Type ?u.21842
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ False

tactic: simpa using congr_arg (Polynomial.aeval x) h
state_before: A : Type u_2
B : Type u_1
B' : Type ?u.21842
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ 1 = 0
Theorem: Finsupp.supported_union
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: erw [Set.union_eq_iUnion, supported_iUnion, iSup_bool_eq]
state_before: α : Type u_1
M : Type u_2
N : Type ?u.110242
P : Type ?u.110245
R : Type u_3
S : Type ?u.110251
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
⊢ supported M R (s ∪ t) = supported M R s ⊔ supported M R t

tactic: rfl
state_before: α : Type u_1
M : Type u_2
N : Type ?u.110242
P : Type ?u.110245
R : Type u_3
S : Type ?u.110251
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s t : Set α
⊢ supported M R (bif true then s else t) ⊔ supported M R (bif false then s else t) = supported M R s ⊔ supported M R t
Theorem: insert_mem_nhdsWithin_insert
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp [mem_of_superset h]
state_before: α : Type u_1
β : Type ?u.20353
γ : Type ?u.20356
δ : Type ?u.20359
inst✝ : TopologicalSpace α
a : α
s t : Set α
h : t ∈ 𝓝[s] a
⊢ insert a t ∈ 𝓝[insert a s] a
Theorem: Subgroup.closure_singleton_one
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [eq_bot_iff_forall, mem_closure_singleton]
state_before: G : Type u_1
G' : Type ?u.220679
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.220688
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
⊢ closure {1} = ⊥
Theorem: List.Func.nil_sub
File: Mathlib/Data/List/Func.lean

tactic: rw [sub, @nil_pointwise _ _ _ ⟨0⟩ ⟨0⟩]
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
⊢ sub [] as = neg as

tactic: congr with x
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
⊢ map (Sub.sub default) as = neg as

tactic: exact zero_sub x
state_before: case e_f.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
x : α
⊢ Sub.sub default x = -x
Theorem: ApproximatesLinearOn.lipschitz
File: Mathlib/Analysis/Calculus/Inverse.lean

tactic: simpa only [restrict_apply, add_sub_cancel'_right] using
  (f'.lipschitz.restrict s).add hf.lipschitz_sub
state_before: 𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
G : Type ?u.49416
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
G' : Type ?u.49519
inst✝² : NormedAddCommGroup G'
inst✝¹ : NormedSpace 𝕜 G'
ε : ℝ
inst✝ : CompleteSpace E
f : E → F
f' : E →L[𝕜] F
s t : Set E
c c' : ℝ≥0
hf : ApproximatesLinearOn f f' s c
⊢ LipschitzWith (‖f'‖₊ + c) (restrict s f)
Theorem: Bool.not_eq_false_eq_eq_true
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases a <;> simp
state_before: a : Bool
⊢ ((!a) = false) = (a = true)
Theorem: List.dProdIndex_eq_map_sum
File: Mathlib/Algebra/GradedMonoid.lean

tactic: match l with
| [] => simp
| head::tail => simp [List.dProdIndex_eq_map_sum tail fι]
state_before: ι : Type u_2
α : Type u_1
A : ι → Type ?u.43971
inst✝¹ : AddMonoid ι
inst✝ : GradedMonoid.GMonoid A
l : List α
fι : α → ι
⊢ dProdIndex l fι = sum (map fι l)

tactic: simp
state_before: ι : Type u_2
α : Type u_1
A : ι → Type ?u.43971
inst✝¹ : AddMonoid ι
inst✝ : GradedMonoid.GMonoid A
l : List α
fι : α → ι
⊢ dProdIndex [] fι = sum (map fι [])

tactic: simp [List.dProdIndex_eq_map_sum tail fι]
state_before: ι : Type u_2
α : Type u_1
A : ι → Type ?u.43971
inst✝¹ : AddMonoid ι
inst✝ : GradedMonoid.GMonoid A
l : List α
fι : α → ι
head : α
tail : List α
⊢ dProdIndex (head :: tail) fι = sum (map fι (head :: tail))
Theorem: CategoryTheory.Abelian.exact_of_is_cokernel
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: refine' (exact_iff _ _).2 ⟨w, _⟩
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
h : IsColimit (CokernelCofork.ofπ g w)
⊢ Exact f g

tactic: have := h.fac (CokernelCofork.ofπ _ (cokernel.condition f)) WalkingParallelPair.one
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
h : IsColimit (CokernelCofork.ofπ g w)
⊢ kernel.ι g ≫ cokernel.π f = 0

tactic: simp only [Cofork.ofπ_ι_app] at this
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
h : IsColimit (CokernelCofork.ofπ g w)
this :
  (CokernelCofork.ofπ g w).ι.app WalkingParallelPair.one ≫
      IsColimit.desc h (CokernelCofork.ofπ (cokernel.π f) (_ : f ≫ cokernel.π f = 0)) =
    (CokernelCofork.ofπ (cokernel.π f) (_ : f ≫ cokernel.π f = 0)).ι.app WalkingParallelPair.one
⊢ kernel.ι g ≫ cokernel.π f = 0

tactic: rw [← this, ← Category.assoc, kernel.condition, zero_comp]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
h : IsColimit (CokernelCofork.ofπ g w)
this : g ≫ IsColimit.desc h (CokernelCofork.ofπ (cokernel.π f) (_ : f ≫ cokernel.π f = 0)) = cokernel.π f
⊢ kernel.ι g ≫ cokernel.π f = 0
Theorem: InnerProductSpace.continuousLinearMapOfBilin_apply
File: Mathlib/Analysis/InnerProductSpace/Dual.lean

tactic: simp [continuousLinearMapOfBilin]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : CompleteSpace E
B : E →L⋆[𝕜] E →L[𝕜] 𝕜
v w : E
⊢ inner (↑B♯ v) w = ↑(↑B v) w
Theorem: or_right_comm
File: Std/Logic.lean

tactic: rw [or_assoc, or_assoc, @or_comm b]
state_before: a b c : Prop
⊢ (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b
Theorem: Ordnode.size_eq_realSize
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [size, h₁, size_eq_realSize h₂, size_eq_realSize h₃]
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
h₁ : s = size l + size r + 1
h₂ : Sized l
h₃ : Sized r
⊢ size (node s l x r) = realSize (node s l x r)

tactic: rfl
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
h₁ : s = size l + size r + 1
h₂ : Sized l
h₃ : Sized r
⊢ realSize l + realSize r + 1 = realSize (node (realSize l + realSize r + 1) l x r)
Theorem: LinearMap.tailings_succ
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp [tailings]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.567851
M₆ : Type ?u.567854
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ tailings f i (n + 1) = tailings f i n ⊔ tailing f i (n + 1)
Theorem: String.next_of_valid'
File: Std/Data/String/Lemmas.lean

tactic: simp only [next, get_of_valid]
state_before: cs cs' : List Char
⊢ next { data := cs ++ cs' } { byteIdx := utf8Len cs } = { byteIdx := utf8Len cs + csize (List.headD cs' default) }

tactic: rfl
state_before: cs cs' : List Char
⊢ { byteIdx := utf8Len cs } + List.headD cs' default = { byteIdx := utf8Len cs + csize (List.headD cs' default) }
Theorem: Equiv.Perm.subtypePerm_zpow
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: induction' n with n ih
state_before: α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
n : ℤ
hf : ∀ (x : α), p x ↔ p (↑f x)
⊢ subtypePerm f hf ^ n = subtypePerm (f ^ n) (_ : ∀ (x : α), p x ↔ p (↑(f ^ n) x))

tactic: exact subtypePerm_pow _ _ _
state_before: case ofNat
α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
hf : ∀ (x : α), p x ↔ p (↑f x)
n : ℕ
⊢ subtypePerm f hf ^ Int.ofNat n = subtypePerm (f ^ Int.ofNat n) (_ : ∀ (x : α), p x ↔ p (↑(f ^ Int.ofNat n) x))

tactic: simp only [zpow_negSucc, subtypePerm_pow, subtypePerm_inv]
state_before: case negSucc
α : Type u
β : Type v
p : α → Prop
f✝ f : Perm α
hf : ∀ (x : α), p x ↔ p (↑f x)
ih : ℕ
⊢ subtypePerm f hf ^ Int.negSucc ih =
    subtypePerm (f ^ Int.negSucc ih) (_ : ∀ (x : α), p x ↔ p (↑(f ^ Int.negSucc ih) x))
Theorem: Polynomial.splits_iff_card_roots
File: Mathlib/Data/Polynomial/Splits.lean

tactic: constructor
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
⊢ Splits (RingHom.id K) p ↔ ↑Multiset.card (roots p) = natDegree p

tactic: intro H
state_before: case mp
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
⊢ Splits (RingHom.id K) p → ↑Multiset.card (roots p) = natDegree p

tactic: rw [natDegree_eq_card_roots H, map_id]
state_before: case mp
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
H : Splits (RingHom.id K) p
⊢ ↑Multiset.card (roots p) = natDegree p

tactic: intro hroots
state_before: case mpr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
⊢ ↑Multiset.card (roots p) = natDegree p → Splits (RingHom.id K) p

tactic: rw [splits_iff_exists_multiset (RingHom.id K)]
state_before: case mpr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ Splits (RingHom.id K) p

tactic: use p.roots
state_before: case mpr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ ∃ s, map (RingHom.id K) p = ↑C (↑(RingHom.id K) (leadingCoeff p)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) s)

tactic: simp only [RingHom.id_apply, map_id]
state_before: case mpr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ map (RingHom.id K) p =
    ↑C (↑(RingHom.id K) (leadingCoeff p)) * Multiset.prod (Multiset.map (fun a => X - ↑C a) (roots p))

tactic: exact (C_leadingCoeff_mul_prod_multiset_X_sub_C hroots).symm
state_before: case mpr
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
p : K[X]
hroots : ↑Multiset.card (roots p) = natDegree p
⊢ p = ↑C (leadingCoeff p) * Multiset.prod (Multiset.map (fun x => X - ↑C x) (roots p))
Theorem: Filter.comap_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: erw [comap_inf, Filter.comap_comap, Filter.comap_comap]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.4517
ι : Sort ?u.4520
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α → β × γ
b : Filter β
c : Filter γ
⊢ comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c
Theorem: add_eq_zero'
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: rw [neg_eq]
state_before: α : Type u_1
β : Type ?u.3681
γ : Type ?u.3684
inst✝ : BooleanRing α
a b : α
⊢ a = -b ↔ a = b
Theorem: Fin.sub_one_lt_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [not_lt, le_sub_one_iff, le_zero_iff]
state_before: n✝ m n : ℕ
k : Fin (n + 1)
⊢ ¬k - 1 < k ↔ ¬0 < k
Theorem: left_eq_midpoint_iff
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [eq_comm, midpoint_eq_left_iff]
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.93636
P : Type u_1
P' : Type ?u.93642
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ x = midpoint R x y ↔ x = y
Theorem: Nat.iSup_lt_succ'
File: Mathlib/Data/Nat/Lattice.lean

tactic: rw [← sup_iSup_nat_succ]
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ (⨆ (k : ℕ) (_ : k < n + 1), u k) = u 0 ⊔ ⨆ (k : ℕ) (_ : k < n), u (k + 1)

tactic: simp
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ((⨆ (_ : 0 < n + 1), u 0) ⊔ ⨆ (i : ℕ) (_ : i + 1 < n + 1), u (i + 1)) = u 0 ⊔ ⨆ (k : ℕ) (_ : k < n), u (k + 1)
Theorem: Nat.fib_coprime_fib_succ
File: Mathlib/Data/Nat/Fib.lean

tactic: induction' n with n ih
state_before: n : ℕ
⊢ coprime (fib n) (fib (n + 1))

tactic: simp
state_before: case zero

⊢ coprime (fib zero) (fib (zero + 1))

tactic: rw [fib_add_two]
state_before: case succ
n : ℕ
ih : coprime (fib n) (fib (n + 1))
⊢ coprime (fib (succ n)) (fib (succ n + 1))

tactic: simp only [coprime_add_self_right]
state_before: case succ
n : ℕ
ih : coprime (fib n) (fib (n + 1))
⊢ coprime (fib (succ n)) (fib n + fib (n + 1))

tactic: simp [coprime, ih.symm]
state_before: case succ
n : ℕ
ih : coprime (fib n) (fib (n + 1))
⊢ coprime (fib (succ n)) (fib n)
Theorem: Finset.image₂_distrib_subset_right
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_4
α' : Type u_6
β : Type u_5
β' : Type u_7
γ✝ : Type ?u.89133
γ' : Type ?u.89136
δ : Type u_3
δ' : Type ?u.89142
ε : Type u_2
ε' : Type ?u.89148
ζ : Type ?u.89151
ζ' : Type ?u.89154
ν : Type ?u.89157
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 : γ✝
γ : Type u_1
u : Finset γ
f : δ → γ → ε
g : α → β → δ
f₁ : α → γ → α'
f₂ : β → γ → β'
g' : α' → β' → ε
h_distrib : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f₁ a c) (f₂ b c)
⊢ ↑(image₂ f (image₂ g s t) u) ⊆ ↑(image₂ g' (image₂ f₁ s u) (image₂ f₂ t u))

tactic: exact Set.image2_distrib_subset_right h_distrib
state_before: α : Type u_4
α' : Type u_6
β : Type u_5
β' : Type u_7
γ✝ : Type ?u.89133
γ' : Type ?u.89136
δ : Type u_3
δ' : Type ?u.89142
ε : Type u_2
ε' : Type ?u.89148
ζ : Type ?u.89151
ζ' : Type ?u.89154
ν : Type ?u.89157
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 : γ✝
γ : Type u_1
u : Finset γ
f : δ → γ → ε
g : α → β → δ
f₁ : α → γ → α'
f₂ : β → γ → β'
g' : α' → β' → ε
h_distrib : ∀ (a : α) (b : β) (c : γ), f (g a b) c = g' (f₁ a c) (f₂ b c)
⊢ image2 f (image2 g ↑s ↑t) ↑u ⊆ image2 g' (image2 f₁ ↑s ↑u) (image2 f₂ ↑t ↑u)
Theorem: pow_nonneg
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [pow_zero]
state_before: α : Type u
β : Type ?u.13277
inst✝ : OrderedSemiring α
a b c d : α
H : 0 ≤ a
⊢ 0 ≤ a ^ 0

tactic: exact zero_le_one
state_before: α : Type u
β : Type ?u.13277
inst✝ : OrderedSemiring α
a b c d : α
H : 0 ≤ a
⊢ 0 ≤ 1

tactic: rw [pow_succ]
state_before: α : Type u
β : Type ?u.13277
inst✝ : OrderedSemiring α
a b c d : α
H : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (n + 1)

tactic: exact mul_nonneg H (pow_nonneg H _)
state_before: α : Type u
β : Type ?u.13277
inst✝ : OrderedSemiring α
a b c d : α
H : 0 ≤ a
n : ℕ
⊢ 0 ≤ a * a ^ n
Theorem: Pmf.toMeasure_bindOnSupport_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp only [toMeasure_apply_eq_toOuterMeasure_apply _ _ hs, toOuterMeasure_bindOnSupport_apply]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.156387
p : Pmf α
f : (a : α) → a ∈ support p → Pmf β
s : Set β
inst✝ : MeasurableSpace β
hs : MeasurableSet s
⊢ ↑↑(toMeasure (bindOnSupport p f)) s = ∑' (a : α), ↑p a * if h : ↑p a = 0 then 0 else ↑↑(toMeasure (f a h)) s
Theorem: IsometryEquiv.image_emetric_ball
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.preimage_symm, h.symm.preimage_emetric_ball, symm_symm]
state_before: ι : Type ?u.725615
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
h : α ≃ᵢ β
x : α
r : ℝ≥0∞
⊢ ↑h '' EMetric.ball x r = EMetric.ball (↑h x) r
Theorem: Convex.mem_smul_of_zero_mem
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ (zero_lt_one.trans_le ht).ne']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.256081
β : Type ?u.256084
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x : E
zero_mem : 0 ∈ s
hx : x ∈ s
t : 𝕜
ht : 1 ≤ t
⊢ x ∈ t • s

tactic: exact h.smul_mem_of_zero_mem zero_mem hx ⟨inv_nonneg.2 (zero_le_one.trans ht), inv_le_one ht⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.256081
β : Type ?u.256084
inst✝⁴ : LinearOrderedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
h : Convex 𝕜 s
x : E
zero_mem : 0 ∈ s
hx : x ∈ s
t : 𝕜
ht : 1 ≤ t
⊢ t⁻¹ • x ∈ s
Theorem: Matrix.rank_le_card_width
File: Mathlib/Data/Matrix/Rank.lean

tactic: haveI : Module.Finite R (n → R) := Module.Finite.pi
state_before: l : Type ?u.15349
m : Type u_2
n : Type u_3
o : Type ?u.15358
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
⊢ rank A ≤ Fintype.card n

tactic: haveI : Module.Free R (n → R) := Module.Free.pi _ _
state_before: l : Type ?u.15349
m : Type u_2
n : Type u_3
o : Type ?u.15358
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this : Module.Finite R (n → R)
⊢ rank A ≤ Fintype.card n

tactic: exact A.mulVecLin.finrank_range_le.trans_eq (finrank_pi _)
state_before: l : Type ?u.15349
m : Type u_2
n : Type u_3
o : Type ?u.15358
R : Type u_1
m_fin : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this✝ : Module.Finite R (n → R)
this : Module.Free R (n → R)
⊢ rank A ≤ Fintype.card n
Theorem: Filter.inf_neBot_iff_frequently_right
File: Mathlib/Order/Filter/Bases.lean

tactic: rw [inf_comm]
state_before: α : Type u_1
β : Type ?u.61014
γ : Type ?u.61017
ι : Sort ?u.61020
ι' : Sort ?u.61023
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f g : Filter α
⊢ NeBot (f ⊓ g) ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x

tactic: exact inf_neBot_iff_frequently_left
state_before: α : Type u_1
β : Type ?u.61014
γ : Type ?u.61017
ι : Sort ?u.61020
ι' : Sort ?u.61023
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
f g : Filter α
⊢ NeBot (g ⊓ f) ↔ ∀ {p : α → Prop}, (∀ᶠ (x : α) in g, p x) → ∃ᶠ (x : α) in f, p x
Theorem: Submodule.span_attach_biUnion
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp [span_iUnion]
state_before: R : Type u_3
R₂ : Type ?u.43659
K : Type ?u.43662
M : Type u_1
M₂ : Type ?u.43668
V : Type ?u.43671
S : Type ?u.43674
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
x : M
p p' : Submodule R M
inst✝³ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R₂ M₂
s✝ t : Set M
inst✝ : DecidableEq M
α : Type u_2
s : Finset α
f : { x // x ∈ s } → Finset M
⊢ span R ↑(Finset.biUnion (Finset.attach s) f) = ⨆ (x : { x // x ∈ s }), span R ↑(f x)
Theorem: Composition.sizeUpTo_strict_mono
File: Mathlib/Combinatorics/Composition.lean

tactic: rw [c.sizeUpTo_succ h]
state_before: n : ℕ
c : Composition n
i : ℕ
h : i < length c
⊢ sizeUpTo c i < sizeUpTo c (i + 1)

tactic: simp
state_before: n : ℕ
c : Composition n
i : ℕ
h : i < length c
⊢ sizeUpTo c i < sizeUpTo c i + nthLe c.blocks i h
Theorem: Filter.frequently_high_scores
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa [frequently_atTop] using high_scores hu
state_before: ι : Type ?u.75677
ι' : Type ?u.75680
α : Type ?u.75683
β : Type u_1
γ : Type ?u.75689
inst✝¹ : LinearOrder β
inst✝ : NoMaxOrder β
u : ℕ → β
hu : Tendsto u atTop atTop
⊢ ∃ᶠ (n : ℕ) in atTop, ∀ (k : ℕ), k < n → u k < u n
Theorem: finprod_cond_ne
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: apply finprod_cond_eq_prod_of_cond_iff
state_before: α : Type u_1
β : Type ?u.190903
ι : Type ?u.190906
G : Type ?u.190909
M : Type u_2
N : Type ?u.190915
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
a : α
inst✝ : DecidableEq α
hf : Set.Finite (mulSupport f)
⊢ (∏ᶠ (i : α) (_ : i ≠ a), f i) = ∏ i in Finset.erase (Finite.toFinset hf) a, f i

tactic: intro x hx
state_before: case h
α : Type u_1
β : Type ?u.190903
ι : Type ?u.190906
G : Type ?u.190909
M : Type u_2
N : Type ?u.190915
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
a : α
inst✝ : DecidableEq α
hf : Set.Finite (mulSupport f)
⊢ ∀ {x : α}, f x ≠ 1 → (x ≠ a ↔ x ∈ Finset.erase (Finite.toFinset hf) a)

tactic: rw [Finset.mem_erase, Finite.mem_toFinset, mem_mulSupport]
state_before: case h
α : Type u_1
β : Type ?u.190903
ι : Type ?u.190906
G : Type ?u.190909
M : Type u_2
N : Type ?u.190915
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
a : α
inst✝ : DecidableEq α
hf : Set.Finite (mulSupport f)
x : α
hx : f x ≠ 1
⊢ x ≠ a ↔ x ∈ Finset.erase (Finite.toFinset hf) a

tactic: exact ⟨fun h => And.intro h hx, fun h => h.1⟩
state_before: case h
α : Type u_1
β : Type ?u.190903
ι : Type ?u.190906
G : Type ?u.190909
M : Type u_2
N : Type ?u.190915
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
a : α
inst✝ : DecidableEq α
hf : Set.Finite (mulSupport f)
x : α
hx : f x ≠ 1
⊢ x ≠ a ↔ x ≠ a ∧ f x ≠ 1