tasksource/leandojo huggingface dataset:
Theorem: JoinedIn.joined_subtype
File: Mathlib/Topology/PathConnected.lean

tactic: continuity
state_before: X : Type u_1
Y : Type ?u.563745
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.563760
F : Set X
h : JoinedIn F x y
⊢ Continuous fun t => { val := ↑(somePath h) t, property := (_ : ↑(somePath h) t ∈ F) }

tactic: simp
state_before: X : Type u_1
Y : Type ?u.563745
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.563760
F : Set X
h : JoinedIn F x y
⊢ ContinuousMap.toFun (ContinuousMap.mk fun t => { val := ↑(somePath h) t, property := (_ : ↑(somePath h) t ∈ F) }) 0 =
    { val := x, property := (_ : x ∈ F) }

tactic: simp
state_before: X : Type u_1
Y : Type ?u.563745
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.563760
F : Set X
h : JoinedIn F x y
⊢ ContinuousMap.toFun (ContinuousMap.mk fun t => { val := ↑(somePath h) t, property := (_ : ↑(somePath h) t ∈ F) }) 1 =
    { val := y, property := (_ : y ∈ F) }
Theorem: BooleanRing.sup_comm
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type ?u.12720
γ : Type ?u.12723
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a + b + a * b = b + a + b * a
Theorem: List.cons_getElem_zero
File: src/lean/Init/Data/List/Basic.lean

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
a : α
as : List α
h : 0 < length (a :: as)
⊢ getElem (a :: as) 0 h = a
Theorem: Polynomial.monic_multiset_prod_of_monic
File: Mathlib/Data/Polynomial/Monic.lean

tactic: revert ht
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
ht : ∀ (i : ι), i ∈ t → Monic (f i)
⊢ Monic (Multiset.prod (Multiset.map f t))

tactic: refine' t.induction_on _ _
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ (∀ (i : ι), i ∈ t → Monic (f i)) → Monic (Multiset.prod (Multiset.map f t))

tactic: intro a t ih ht
state_before: case refine'_2
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ ∀ ⦃a : ι⦄ {s : Multiset ι},
    ((∀ (i : ι), i ∈ s → Monic (f i)) → Monic (Multiset.prod (Multiset.map f s))) →
      (∀ (i : ι), i ∈ a ::ₘ s → Monic (f i)) → Monic (Multiset.prod (Multiset.map f (a ::ₘ s)))

tactic: rw [Multiset.map_cons, Multiset.prod_cons]
state_before: case refine'_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ (i : ι), i ∈ t → Monic (f i)) → Monic (Multiset.prod (Multiset.map f t))
ht : ∀ (i : ι), i ∈ a ::ₘ t → Monic (f i)
⊢ Monic (Multiset.prod (Multiset.map f (a ::ₘ t)))

tactic: exact (ht _ (Multiset.mem_cons_self _ _)).mul (ih fun _ hi => ht _ (Multiset.mem_cons_of_mem hi))
state_before: case refine'_2
R : Type u
S : Type v
a✝ b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t✝ : Multiset ι
f : ι → R[X]
a : ι
t : Multiset ι
ih : (∀ (i : ι), i ∈ t → Monic (f i)) → Monic (Multiset.prod (Multiset.map f t))
ht : ∀ (i : ι), i ∈ a ::ₘ t → Monic (f i)
⊢ Monic (f a * Multiset.prod (Multiset.map f t))

tactic: simp
state_before: case refine'_1
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : CommSemiring R
p : R[X]
t : Multiset ι
f : ι → R[X]
⊢ (∀ (i : ι), i ∈ 0 → Monic (f i)) → Monic (Multiset.prod (Multiset.map f 0))
Theorem: FiniteDimensional.rank_lt_aleph0
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: simp only [Module.rank_def]
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.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
⊢ Module.rank R M < ℵ₀

tactic: letI := nontrivial_of_invariantBasisNumber R
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.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
⊢ (⨆ (ι : { s // LinearIndependent R Subtype.val }), #↑↑ι) < ℵ₀

tactic: obtain ⟨S, hS⟩ := Module.finite_def.mp ‹Module.Finite R 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.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ (⨆ (ι : { s // LinearIndependent R Subtype.val }), #↑↑ι) < ℵ₀

tactic: refine' (ciSup_le' fun i => _).trans_lt (nat_lt_aleph0 S.card)
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.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
S : Finset M
hS : Submodule.span R ↑S = ⊤
⊢ (⨆ (ι : { s // LinearIndependent R Subtype.val }), #↑↑ι) < ℵ₀

tactic: exact linearIndependent_le_span_finset _ i.prop S hS
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.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
S : Finset M
hS : Submodule.span R ↑S = ⊤
i : { s // LinearIndependent R Subtype.val }
⊢ (#↑↑i) ≤ ↑(Finset.card S)
Theorem: Nat.digits_of_lt
File: Mathlib/Data/Nat/Digits.lean

tactic: rcases exists_eq_succ_of_ne_zero hx with ⟨x, rfl⟩
state_before: n b x : ℕ
hx : x ≠ 0
hxb : x < b
⊢ digits b x = [x]

tactic: rcases exists_eq_add_of_le' ((Nat.le_add_left 1 x).trans_lt hxb) with ⟨b, rfl⟩
state_before: case intro
n b x : ℕ
hx : succ x ≠ 0
hxb : succ x < b
⊢ digits b (succ x) = [succ x]

tactic: rw [digits_add_two_add_one, div_eq_of_lt hxb, digits_zero, mod_eq_of_lt hxb]
state_before: case intro.intro
n x : ℕ
hx : succ x ≠ 0
b : ℕ
hxb : succ x < b + succ 1
⊢ digits (b + succ 1) (succ x) = [succ x]
Theorem: IsLocalization.map_comap
File: Mathlib/RingTheory/Localization/Ideal.lean

tactic: obtain ⟨r, s, hx⟩ := mk'_surjective M x
state_before: R : Type u_2
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
J : Ideal S
x : S
hJ : x ∈ J
⊢ x ∈ Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) J)

tactic: rw [← hx] at hJ⊢
state_before: case intro.intro
R : Type u_2
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
J : Ideal S
x : S
hJ : x ∈ J
r : R
s : { x // x ∈ M }
hx : mk' S r s = x
⊢ x ∈ Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) J)

tactic: exact
  Ideal.mul_mem_right _ _
    (Ideal.mem_map_of_mem _
      (show (algebraMap R S) r ∈ J from
        mk'_spec S r s ▸ J.mul_mem_right ((algebraMap R S) s) hJ))
state_before: case intro.intro
R : Type u_2
inst✝³ : CommSemiring R
M : Submonoid R
S : Type u_1
inst✝² : CommSemiring S
inst✝¹ : Algebra R S
inst✝ : IsLocalization M S
J : Ideal S
x : S
r : R
s : { x // x ∈ M }
hJ : mk' S r s ∈ J
hx : mk' S r s = x
⊢ mk' S r s ∈ Ideal.map (algebraMap R S) (Ideal.comap (algebraMap R S) J)
Theorem: Asymptotics.isTheta_const_mul_left
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simpa only [← smul_eq_mul] using isTheta_const_smul_left hc
state_before: α : Type u_2
β : Type ?u.59587
E : Type ?u.59590
F : Type u_3
G : Type ?u.59596
E' : Type ?u.59599
F' : Type ?u.59602
G' : Type ?u.59605
E'' : Type ?u.59608
F'' : Type ?u.59611
G'' : Type ?u.59614
R : Type ?u.59617
R' : Type ?u.59620
𝕜 : Type u_1
𝕜' : Type ?u.59626
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
c : 𝕜
f : α → 𝕜
hc : c ≠ 0
⊢ (fun x => c * f x) =Θ[l] g ↔ f =Θ[l] g
Theorem: Int.mul_left_comm
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.mul_assoc, ← Int.mul_assoc, Int.mul_comm a]
state_before: a b c : Int
⊢ a * (b * c) = b * (a * c)
Theorem: LocalHomeomorph.isBigO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def]
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : LocalHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ f =O[𝓝 b] g ↔ (f ∘ ↑e) =O[𝓝 (↑(LocalHomeomorph.symm e) b)] (g ∘ ↑e)

tactic: exact exists_congr fun C => e.isBigOWith_congr hb
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : LocalHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ (∃ c, IsBigOWith c (𝓝 b) f g) ↔ ∃ c, IsBigOWith c (𝓝 (↑(LocalHomeomorph.symm e) b)) (f ∘ ↑e) (g ∘ ↑e)
Theorem: Polynomial.Monic.mul_natDegree_lt_iff
File: Mathlib/Data/Polynomial/Monic.lean

tactic: by_cases hq : q = 0
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
⊢ natDegree (p * q) < natDegree p ↔ p ≠ 1 ∧ q = 0

tactic: suffices 0 < p.natDegree ↔ p.natDegree ≠ 0 by simpa [hq, ← h.natDegree_eq_zero_iff_eq_one]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
hq : q = 0
⊢ natDegree (p * q) < natDegree p ↔ p ≠ 1 ∧ q = 0

tactic: exact ⟨fun h => h.ne', fun h => lt_of_le_of_ne (Nat.zero_le _) h.symm⟩
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
hq : q = 0
⊢ 0 < natDegree p ↔ natDegree p ≠ 0

tactic: simpa [hq, ← h.natDegree_eq_zero_iff_eq_one]
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
hq : q = 0
this : 0 < natDegree p ↔ natDegree p ≠ 0
⊢ natDegree (p * q) < natDegree p ↔ p ≠ 1 ∧ q = 0

tactic: simp [h.natDegree_mul', hq]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
h : Monic p
q : R[X]
hq : ¬q = 0
⊢ natDegree (p * q) < natDegree p ↔ p ≠ 1 ∧ q = 0
Theorem: Turing.BlankRel.trans
File: Mathlib/Computability/TuringMachine.lean

tactic: rintro (h₁ | h₁) (h₂ | h₂)
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
⊢ BlankRel l₁ l₂ → BlankRel l₂ l₃ → BlankRel l₁ l₃

tactic: exact Or.inl (h₁.trans h₂)
state_before: case inl.inl
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₁ l₂
h₂ : BlankExtends l₂ l₃
⊢ BlankRel l₁ l₃

tactic: cases' le_total l₁.length l₃.length with h h
state_before: case inl.inr
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₁ l₂
h₂ : BlankExtends l₃ l₂
⊢ BlankRel l₁ l₃

tactic: exact Or.inl (h₁.above_of_le h₂ h)
state_before: case inl.inr.inl
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₁ l₂
h₂ : BlankExtends l₃ l₂
h : List.length l₁ ≤ List.length l₃
⊢ BlankRel l₁ l₃

tactic: exact Or.inr (h₂.above_of_le h₁ h)
state_before: case inl.inr.inr
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₁ l₂
h₂ : BlankExtends l₃ l₂
h : List.length l₃ ≤ List.length l₁
⊢ BlankRel l₁ l₃

tactic: cases' le_total l₁.length l₃.length with h h
state_before: case inr.inl
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₂ l₁
h₂ : BlankExtends l₂ l₃
⊢ BlankRel l₁ l₃

tactic: exact Or.inl (h₁.below_of_le h₂ h)
state_before: case inr.inl.inl
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₂ l₁
h₂ : BlankExtends l₂ l₃
h : List.length l₁ ≤ List.length l₃
⊢ BlankRel l₁ l₃

tactic: exact Or.inr (h₂.below_of_le h₁ h)
state_before: case inr.inl.inr
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₂ l₁
h₂ : BlankExtends l₂ l₃
h : List.length l₃ ≤ List.length l₁
⊢ BlankRel l₁ l₃

tactic: exact Or.inr (h₂.trans h₁)
state_before: case inr.inr
Γ : Type u_1
inst✝ : Inhabited Γ
l₁ l₂ l₃ : List Γ
h₁ : BlankExtends l₂ l₁
h₂ : BlankExtends l₃ l₂
⊢ BlankRel l₁ l₃
Theorem: PFun.core_restrict
File: Mathlib/Data/PFun.lean

tactic: ext x
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.48707
δ : Type ?u.48710
ε : Type ?u.48713
ι : Type ?u.48716
f✝ : α →. β
f : α → β
s : Set β
⊢ core (↑f) s = f ⁻¹' s

tactic: simp [core_def]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.48707
δ : Type ?u.48710
ε : Type ?u.48713
ι : Type ?u.48716
f✝ : α →. β
f : α → β
s : Set β
x : α
⊢ x ∈ core (↑f) s ↔ x ∈ f ⁻¹' s
Theorem: Polynomial.prime_of_degree_eq_one
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp1 : degree p = 1
hp0 : p = 0
⊢ ¬degree 0 = 1
Theorem: Set.inj_on_iUnion_of_directed
File: Mathlib/Data/Set/Lattice.lean

tactic: intro x hx y hy hxy
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.191837
ι : Sort u_2
ι' : Sort ?u.191843
ι₂ : Sort ?u.191846
κ : ι → Sort ?u.191851
κ₁ : ι → Sort ?u.191856
κ₂ : ι → Sort ?u.191861
κ' : ι' → Sort ?u.191866
s : ι → Set α
hs : Directed (fun x x_1 => x ⊆ x_1) s
f : α → β
hf : ∀ (i : ι), InjOn f (s i)
⊢ InjOn f (⋃ (i : ι), s i)

tactic: rcases mem_iUnion.1 hx with ⟨i, hx⟩
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.191837
ι : Sort u_2
ι' : Sort ?u.191843
ι₂ : Sort ?u.191846
κ : ι → Sort ?u.191851
κ₁ : ι → Sort ?u.191856
κ₂ : ι → Sort ?u.191861
κ' : ι' → Sort ?u.191866
s : ι → Set α
hs : Directed (fun x x_1 => x ⊆ x_1) s
f : α → β
hf : ∀ (i : ι), InjOn f (s i)
x : α
hx : x ∈ ⋃ (i : ι), s i
y : α
hy : y ∈ ⋃ (i : ι), s i
hxy : f x = f y
⊢ x = y

tactic: rcases mem_iUnion.1 hy with ⟨j, hy⟩
state_before: case intro
α : Type u_1
β : Type u_3
γ : Type ?u.191837
ι : Sort u_2
ι' : Sort ?u.191843
ι₂ : Sort ?u.191846
κ : ι → Sort ?u.191851
κ₁ : ι → Sort ?u.191856
κ₂ : ι → Sort ?u.191861
κ' : ι' → Sort ?u.191866
s : ι → Set α
hs : Directed (fun x x_1 => x ⊆ x_1) s
f : α → β
hf : ∀ (i : ι), InjOn f (s i)
x : α
hx✝ : x ∈ ⋃ (i : ι), s i
y : α
hy : y ∈ ⋃ (i : ι), s i
hxy : f x = f y
i : ι
hx : x ∈ s i
⊢ x = y

tactic: rcases hs i j with ⟨k, hi, hj⟩
state_before: case intro.intro
α : Type u_1
β : Type u_3
γ : Type ?u.191837
ι : Sort u_2
ι' : Sort ?u.191843
ι₂ : Sort ?u.191846
κ : ι → Sort ?u.191851
κ₁ : ι → Sort ?u.191856
κ₂ : ι → Sort ?u.191861
κ' : ι' → Sort ?u.191866
s : ι → Set α
hs : Directed (fun x x_1 => x ⊆ x_1) s
f : α → β
hf : ∀ (i : ι), InjOn f (s i)
x : α
hx✝ : x ∈ ⋃ (i : ι), s i
y : α
hy✝ : y ∈ ⋃ (i : ι), s i
hxy : f x = f y
i : ι
hx : x ∈ s i
j : ι
hy : y ∈ s j
⊢ x = y

tactic: exact hf k (hi hx) (hj hy) hxy
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_3
γ : Type ?u.191837
ι : Sort u_2
ι' : Sort ?u.191843
ι₂ : Sort ?u.191846
κ : ι → Sort ?u.191851
κ₁ : ι → Sort ?u.191856
κ₂ : ι → Sort ?u.191861
κ' : ι' → Sort ?u.191866
s : ι → Set α
hs : Directed (fun x x_1 => x ⊆ x_1) s
f : α → β
hf : ∀ (i : ι), InjOn f (s i)
x : α
hx✝ : x ∈ ⋃ (i : ι), s i
y : α
hy✝ : y ∈ ⋃ (i : ι), s i
hxy : f x = f y
i : ι
hx : x ∈ s i
j : ι
hy : y ∈ s j
k : ι
hi : s i ⊆ s k
hj : s j ⊆ s k
⊢ x = y
Theorem: sup_eq_bot_iff
File: Mathlib/Order/BoundedOrder.lean

tactic: rw [eq_bot_iff, sup_le_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.26825
δ : Type ?u.26828
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
a b : α
⊢ a ⊔ b = ⊥ ↔ a = ⊥ ∧ b = ⊥

tactic: simp
state_before: α : Type u
β : Type v
γ : Type ?u.26825
δ : Type ?u.26828
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
a b : α
⊢ a ≤ ⊥ ∧ b ≤ ⊥ ↔ a = ⊥ ∧ b = ⊥
Theorem: TensorProduct.map_pow
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: induction' n with n ih
state_before: R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.980529
inst✝¹⁷ : Monoid R'
R'' : Type ?u.980535
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.980547
Q : Type ?u.980550
S : Type ?u.980553
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.981680
Q' : Type ?u.981683
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] M
g : N →ₗ[R] N
n : ℕ
⊢ map f g ^ n = map (f ^ n) (g ^ n)

tactic: simp only [Nat.zero_eq, pow_zero, map_one]
state_before: case zero
R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.980529
inst✝¹⁷ : Monoid R'
R'' : Type ?u.980535
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.980547
Q : Type ?u.980550
S : Type ?u.980553
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.981680
Q' : Type ?u.981683
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] M
g : N →ₗ[R] N
⊢ map f g ^ Nat.zero = map (f ^ Nat.zero) (g ^ Nat.zero)

tactic: simp only [pow_succ', ih, map_mul]
state_before: case succ
R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.980529
inst✝¹⁷ : Monoid R'
R'' : Type ?u.980535
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_3
P : Type ?u.980547
Q : Type ?u.980550
S : Type ?u.980553
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.981680
Q' : Type ?u.981683
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
f : M →ₗ[R] M
g : N →ₗ[R] N
n : ℕ
ih : map f g ^ n = map (f ^ n) (g ^ n)
⊢ map f g ^ Nat.succ n = map (f ^ Nat.succ n) (g ^ Nat.succ n)
Theorem: Finset.card_image₂_iff
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [← card_product, ← coe_product]
state_before: α : Type u_2
α' : Type ?u.9016
β : Type u_3
β' : Type ?u.9022
γ : Type u_1
γ' : Type ?u.9028
δ : Type ?u.9031
δ' : Type ?u.9034
ε : Type ?u.9037
ε' : Type ?u.9040
ζ : Type ?u.9043
ζ' : Type ?u.9046
ν : Type ?u.9049
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 : γ
⊢ card (image₂ f s t) = card s * card t ↔ InjOn (fun x => f x.fst x.snd) (↑s ×ˢ ↑t)

tactic: exact card_image_iff
state_before: α : Type u_2
α' : Type ?u.9016
β : Type u_3
β' : Type ?u.9022
γ : Type u_1
γ' : Type ?u.9028
δ : Type ?u.9031
δ' : Type ?u.9034
ε : Type ?u.9037
ε' : Type ?u.9040
ζ : Type ?u.9043
ζ' : Type ?u.9046
ν : Type ?u.9049
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 : γ
⊢ card (image₂ f s t) = card (s ×ˢ t) ↔ InjOn (fun x => f x.fst x.snd) ↑(s ×ˢ t)
Theorem: Set.not_mem_iff_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: unfold boolIndicator
state_before: α : Type u_1
s : Set α
x : α
⊢ ¬x ∈ s ↔ boolIndicator s x = false

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
s : Set α
x : α
⊢ ¬x ∈ s ↔ (if x ∈ s then true else false) = false
Theorem: symmDiff_symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: ac_rfl
state_before: ι : Type ?u.68209
α : Type u_1
β : Type ?u.68215
π : ι → Type ?u.68220
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a \ (b ⊔ c) ⊔ b \ (a ⊔ c) ⊔ (c \ (a ⊔ b) ⊔ c ⊓ a ⊓ b) = a \ (b ⊔ c) ⊔ b \ (a ⊔ c) ⊔ c \ (a ⊔ b) ⊔ a ⊓ b ⊓ c
Theorem: LaurentPolynomial.degree_C_mul_T
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [degree]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ degree (↑C a * T n) = ↑n

tactic: have : Finsupp.support (C a * T n) = {n} := by
  refine' support_eq_singleton.mpr _
  rw [← single_eq_C_mul_T]
  simp only [single_eq_same, a0, Ne.def, not_false_iff, eq_self_iff_true, and_self_iff]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ Finset.max (↑C a * T n).support = ↑n

tactic: rw [this]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (↑C a * T n).support = {n}
⊢ Finset.max (↑C a * T n).support = ↑n

tactic: exact Finset.max_singleton
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
this : (↑C a * T n).support = {n}
⊢ Finset.max {n} = ↑n

tactic: refine' support_eq_singleton.mpr _
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ (↑C a * T n).support = {n}

tactic: rw [← single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ ↑(↑C a * T n) n ≠ 0 ∧ ↑C a * T n = Finsupp.single n (↑(↑C a * T n) n)

tactic: simp only [single_eq_same, a0, Ne.def, not_false_iff, eq_self_iff_true, and_self_iff]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a ≠ 0
⊢ ↑(Finsupp.single n a) n ≠ 0 ∧ Finsupp.single n a = Finsupp.single n (↑(Finsupp.single n a) n)
Theorem: norm_indicator_le_norm_self
File: Mathlib/Analysis/NormedSpace/IndicatorFunction.lean

tactic: rw [norm_indicator_eq_indicator_norm]
state_before: α : Type u_2
E : Type u_1
inst✝ : SeminormedAddCommGroup E
s t : Set α
f : α → E
a : α
⊢ ‖indicator s f a‖ ≤ ‖f a‖

tactic: apply indicator_norm_le_norm_self
state_before: α : Type u_2
E : Type u_1
inst✝ : SeminormedAddCommGroup E
s t : Set α
f : α → E
a : α
⊢ indicator s (fun a => ‖f a‖) a ≤ ‖f a‖
Theorem: Finset.sup'_congr
File: Mathlib/Data/Finset/Lattice.lean

tactic: subst s
state_before: F : Type ?u.262044
α : Type u_2
β : Type u_1
γ : Type ?u.262053
ι : Type ?u.262056
κ : Type ?u.262059
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f✝ : β → α
t : Finset β
f g : β → α
h₁ : s = t
h₂ : ∀ (x : β), x ∈ s → f x = g x
⊢ sup' s H f = sup' t (_ : Finset.Nonempty t) g

tactic: refine' eq_of_forall_ge_iff fun c => _
state_before: F : Type ?u.262044
α : Type u_2
β : Type u_1
γ : Type ?u.262053
ι : Type ?u.262056
κ : Type ?u.262059
inst✝ : SemilatticeSup α
f✝ : β → α
t : Finset β
f g : β → α
H : Finset.Nonempty t
h₂ : ∀ (x : β), x ∈ t → f x = g x
⊢ sup' t H f = sup' t (_ : Finset.Nonempty t) g

tactic: simp (config := { contextual := true }) only [sup'_le_iff, h₂]
state_before: F : Type ?u.262044
α : Type u_2
β : Type u_1
γ : Type ?u.262053
ι : Type ?u.262056
κ : Type ?u.262059
inst✝ : SemilatticeSup α
f✝ : β → α
t : Finset β
f g : β → α
H : Finset.Nonempty t
h₂ : ∀ (x : β), x ∈ t → f x = g x
c : α
⊢ sup' t H f ≤ c ↔ sup' t (_ : Finset.Nonempty t) g ≤ c
Theorem: Filter.HasBasis.eq_iInf
File: Mathlib/Order/Filter/Bases.lean

tactic: simpa only [iInf_true] using h.eq_biInf
state_before: α : Type u_1
β : Type ?u.61688
γ : Type ?u.61691
ι : Sort u_2
ι' : Sort ?u.61697
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : HasBasis l (fun x => True) s
⊢ l = ⨅ (i : ι), 𝓟 (s i)