tasksource/leandojo huggingface dataset:
Theorem: abs_mul_self
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: rw [abs_mul, abs_mul_abs_self]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
a✝ b c a : α
⊢ abs (a * a) = a * a
Theorem: Filter.HasBasis.frequently_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [Filter.Frequently, hl.eventually_iff]
state_before: α : Type u_1
β : Type ?u.19100
γ : Type ?u.19103
ι : Sort u_2
ι' : Sort ?u.19109
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
q : α → Prop
⊢ (∃ᶠ (x : α) in l, q x) ↔ ∀ (i : ι), p i → ∃ x, x ∈ s i ∧ q x

tactic: push_neg
state_before: α : Type u_1
β : Type ?u.19100
γ : Type ?u.19103
ι : Sort u_2
ι' : Sort ?u.19109
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
q : α → Prop
⊢ (¬∃ i, p i ∧ ∀ ⦃x : α⦄, x ∈ s i → ¬q x) ↔ ∀ (i : ι), p i → ∃ x, x ∈ s i ∧ q x

tactic: rfl
state_before: α : Type u_1
β : Type ?u.19100
γ : Type ?u.19103
ι : Sort u_2
ι' : Sort ?u.19109
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
q : α → Prop
⊢ (∀ (i : ι), p i → Exists fun ⦃x⦄ => x ∈ s i ∧ q x) ↔ ∀ (i : ι), p i → ∃ x, x ∈ s i ∧ q x
Theorem: Equiv.Perm.support_mul_le
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp only [sup_eq_union]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ x ∈ support (f * g) → x ∈ support f ⊔ support g

tactic: rw [mem_union, mem_support, mem_support, mem_support, mul_apply, ← not_and_or, not_imp_not]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ x ∈ support (f * g) → x ∈ support f ∪ support g

tactic: rintro ⟨hf, hg⟩
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
⊢ ↑f x = x ∧ ↑g x = x → ↑f (↑g x) = x

tactic: rw [hg, hf]
state_before: case intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g✝ f g : Perm α
x : α
hf : ↑f x = x
hg : ↑g x = x
⊢ ↑f (↑g x) = x
Theorem: Finset.norm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rcases s with ⟨⟨l⟩, hl⟩
state_before: α✝ : Type ?u.116719
β : Type ?u.116722
γ : Type ?u.116725
ι : Type u_2
inst✝¹ : SeminormedRing α✝
α : Type u_1
inst✝ : NormedCommRing α
s : Finset ι
hs : Finset.Nonempty s
f : ι → α
⊢ ‖∏ i in s, f i‖ ≤ ∏ i in s, ‖f i‖

tactic: have : l.map f ≠ [] := by simpa using hs
state_before: case mk.mk
α✝ : Type ?u.116719
β : Type ?u.116722
γ : Type ?u.116725
ι : Type u_2
inst✝¹ : SeminormedRing α✝
α : Type u_1
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : Finset.Nonempty { val := Quot.mk Setoid.r l, nodup := hl }
⊢ ‖∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖

tactic: simpa using List.norm_prod_le' this
state_before: case mk.mk
α✝ : Type ?u.116719
β : Type ?u.116722
γ : Type ?u.116725
ι : Type u_2
inst✝¹ : SeminormedRing α✝
α : Type u_1
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : Finset.Nonempty { val := Quot.mk Setoid.r l, nodup := hl }
this : List.map f l ≠ []
⊢ ‖∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, f i‖ ≤ ∏ i in { val := Quot.mk Setoid.r l, nodup := hl }, ‖f i‖

tactic: simpa using hs
state_before: α✝ : Type ?u.116719
β : Type ?u.116722
γ : Type ?u.116725
ι : Type u_2
inst✝¹ : SeminormedRing α✝
α : Type u_1
inst✝ : NormedCommRing α
f : ι → α
val✝ : Multiset ι
l : List ι
hl : Multiset.Nodup (Quot.mk Setoid.r l)
hs : Finset.Nonempty { val := Quot.mk Setoid.r l, nodup := hl }
⊢ List.map f l ≠ []
Theorem: PosNum.natSize_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← size_eq_natSize, size_to_nat]
state_before: α : Type ?u.335729
n : PosNum
⊢ natSize n = Nat.size ↑n
Theorem: FiniteDimensional.basisSingleton_apply
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: cases Unique.uniq ‹Unique ι› i
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
i : ι
⊢ ↑(basisSingleton ι h v hv) i = v

tactic: simp [basisSingleton]
state_before: case refl
K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
ι : Type u_1
inst✝ : Unique ι
h : finrank K V = 1
v : V
hv : v ≠ 0
⊢ ↑(basisSingleton ι h v hv) default = v
Theorem: Nat.count_lt_count_succ_iff
File: Mathlib/Data/Nat/Count.lean

tactic: by_cases h : p n <;> simp [count_succ, h]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n < count p (n + 1) ↔ p n
Theorem: Set.Nontrivial.exists_ne
File: Mathlib/Data/Set/Basic.lean

tactic: by_contra' H
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hs : Set.Nontrivial s
z : α
⊢ ∃ x, x ∈ s ∧ x ≠ z

tactic: rcases hs with ⟨x, hx, y, hy, hxy⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
hs : Set.Nontrivial s
z : α
H : ∀ (x : α), x ∈ s → x = z
⊢ False

tactic: rw [H x hx, H y hy] at hxy
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
z : α
H : ∀ (x : α), x ∈ s → x = z
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
⊢ False

tactic: exact hxy rfl
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
z : α
H : ∀ (x : α), x ∈ s → x = z
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : z ≠ z
⊢ False
Theorem: liouville_liouvilleNumber
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

tactic: have mZ1 : 1 < (m : ℤ) := by norm_cast
state_before: m : ℕ
hm : 2 ≤ m
⊢ Liouville (liouvilleNumber ↑m)

tactic: have m1 : 1 < (m : ℝ) := by norm_cast
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
⊢ Liouville (liouvilleNumber ↑m)

tactic: intro n
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
⊢ Liouville (liouvilleNumber ↑m)

tactic: rcases partialSum_eq_rat (zero_lt_two.trans_le hm) n with ⟨p, hp⟩
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n : ℕ
⊢ ∃ a b, 1 < b ∧ liouvilleNumber ↑m ≠ ↑a / ↑b ∧ abs (liouvilleNumber ↑m - ↑a / ↑b) < 1 / ↑b ^ n

tactic: refine' ⟨p, m ^ n !, by rw [Nat.cast_pow]; exact one_lt_pow mZ1 n.factorial_ne_zero, _⟩
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑(m ^ n !)
⊢ ∃ a b, 1 < b ∧ liouvilleNumber ↑m ≠ ↑a / ↑b ∧ abs (liouvilleNumber ↑m - ↑a / ↑b) < 1 / ↑b ^ n

tactic: push_cast
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑(m ^ n !)
⊢ liouvilleNumber ↑m ≠ ↑↑p / ↑↑(m ^ n !) ∧ abs (liouvilleNumber ↑m - ↑↑p / ↑↑(m ^ n !)) < 1 / ↑↑(m ^ n !) ^ n

tactic: rw [Nat.cast_pow] at hp
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑(m ^ n !)
⊢ liouvilleNumber ↑m ≠ ↑p / ↑m ^ n ! ∧ abs (liouvilleNumber ↑m - ↑p / ↑m ^ n !) < 1 / (↑m ^ n !) ^ n

tactic: rw [← partialSum_add_remainder m1 n, ← hp]
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑m ^ n !
⊢ liouvilleNumber ↑m ≠ ↑p / ↑m ^ n ! ∧ abs (liouvilleNumber ↑m - ↑p / ↑m ^ n !) < 1 / (↑m ^ n !) ^ n

tactic: have hpos := remainder_pos m1 n
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑m ^ n !
⊢ partialSum (↑m) n + remainder (↑m) n ≠ partialSum (↑m) n ∧
    abs (partialSum (↑m) n + remainder (↑m) n - partialSum (↑m) n) < 1 / (↑m ^ n !) ^ n

tactic: simpa [abs_of_pos hpos, hpos.ne'] using @remainder_lt n m (by assumption_mod_cast)
state_before: case intro
m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑m ^ n !
hpos : 0 < remainder (↑m) n
⊢ partialSum (↑m) n + remainder (↑m) n ≠ partialSum (↑m) n ∧
    abs (partialSum (↑m) n + remainder (↑m) n - partialSum (↑m) n) < 1 / (↑m ^ n !) ^ n

tactic: norm_cast
state_before: m : ℕ
hm : 2 ≤ m
⊢ 1 < ↑m

tactic: norm_cast
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
⊢ 1 < ↑m

tactic: rw [Nat.cast_pow]
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑(m ^ n !)
⊢ 1 < ↑(m ^ n !)

tactic: exact one_lt_pow mZ1 n.factorial_ne_zero
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑(m ^ n !)
⊢ 1 < ↑m ^ n !

tactic: assumption_mod_cast
state_before: m : ℕ
hm : 2 ≤ m
mZ1 : 1 < ↑m
m1 : 1 < ↑m
n p : ℕ
hp : partialSum (↑m) n = ↑p / ↑m ^ n !
hpos : 0 < remainder (↑m) n
⊢ 2 ≤ ↑m
Theorem: List.orderedInsert_eq_take_drop
File: Mathlib/Data/List/Sort.lean

tactic: dsimp only [orderedInsert]
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
⊢ orderedInsert r a (b :: l) =
    takeWhile (fun b => decide ¬r a b) (b :: l) ++ a :: dropWhile (fun b => decide ¬r a b) (b :: l)

tactic: split_ifs with h <;> simp [takeWhile, dropWhile, *, orderedInsert_eq_take_drop a l]
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
⊢ (if r a b then a :: b :: l else b :: orderedInsert r a l) =
    takeWhile (fun b => decide ¬r a b) (b :: l) ++ a :: dropWhile (fun b => decide ¬r a b) (b :: l)
Theorem: Complex.frontier_reProdIm
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [← preimage_eq_preimage equivRealProdClm.symm.toHomeomorph.surjective,
  equivRealProdClm.symm.toHomeomorph.preimage_frontier] using frontier_prod_eq s t
state_before: s t : Set ℝ
⊢ frontier (s ×ℂ t) = closure s ×ℂ frontier t ∪ frontier s ×ℂ closure t
Theorem: Set.ncard_le_one_iff
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_le_one hs]
state_before: α : Type u_1
β : Type ?u.150013
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard s ≤ 1 ↔ ∀ {a b : α}, a ∈ s → b ∈ s → a = b

tactic: tauto
state_before: α : Type u_1
β : Type ?u.150013
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ (∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → a = b) ↔ ∀ {a b : α}, a ∈ s → b ∈ s → a = b
Theorem: AddAction.orbitZmultiplesEquiv_symm_apply'
File: Mathlib/Data/ZMod/Quotient.lean

tactic: rw [AddAction.orbit_zmultiples_equiv_symm_apply, ZMod.coe_int_cast]
state_before: n : ℕ
A : Type ?u.312437
R : Type ?u.312440
inst✝⁵ : AddGroup A
inst✝⁴ : Ring R
α✝ : Type ?u.312449
β✝ : Type ?u.312452
inst✝³ : Group α✝
a✝ : α✝
inst✝² : MulAction α✝ β✝
b✝ : β✝
α : Type u_1
β : Type u_2
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
k : ℤ
⊢ ↑(orbitZmultiplesEquiv a b).symm ↑k =
    k • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) }

tactic: exact Subtype.ext (zsmul_vadd_mod_minimalPeriod a b k)
state_before: n : ℕ
A : Type ?u.312437
R : Type ?u.312440
inst✝⁵ : AddGroup A
inst✝⁴ : Ring R
α✝ : Type ?u.312449
β✝ : Type ?u.312452
inst✝³ : Group α✝
a✝ : α✝
inst✝² : MulAction α✝ β✝
b✝ : β✝
α : Type u_1
β : Type u_2
inst✝¹ : AddGroup α
a : α
inst✝ : AddAction α β
b : β
k : ℤ
⊢ (k % ↑(minimalPeriod ((fun x x_1 => x +ᵥ x_1) a) b)) • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) } =
    k • { val := a, property := (_ : a ∈ zmultiples a) } +ᵥ
      { val := b, property := (_ : b ∈ AddAction.orbit { x // x ∈ zmultiples a } b) }
Theorem: Continuous.isOpenPosMeasure_map
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: refine' ⟨fun U hUo hUne => _⟩
state_before: α : Type ?u.877436
β : Type u_1
γ : Type u_2
γ₂ : Type ?u.877445
δ : Type ?u.877448
ι : Sort y
s t u : Set α
inst✝¹⁵ : TopologicalSpace α
inst✝¹⁴ : MeasurableSpace α
inst✝¹³ : OpensMeasurableSpace α
inst✝¹² : TopologicalSpace β
inst✝¹¹ : MeasurableSpace β
inst✝¹⁰ : OpensMeasurableSpace β
inst✝⁹ : TopologicalSpace γ
inst✝⁸ : MeasurableSpace γ
inst✝⁷ : BorelSpace γ
inst✝⁶ : TopologicalSpace γ₂
inst✝⁵ : MeasurableSpace γ₂
inst✝⁴ : BorelSpace γ₂
inst✝³ : MeasurableSpace δ
α' : Type ?u.877541
inst✝² : TopologicalSpace α'
inst✝¹ : MeasurableSpace α'
f : β → γ
hf : Continuous f
hf_surj : Function.Surjective f
μ : MeasureTheory.Measure β
inst✝ : Measure.IsOpenPosMeasure μ
⊢ Measure.IsOpenPosMeasure (Measure.map f μ)

tactic: rw [Measure.map_apply hf.measurable hUo.measurableSet]
state_before: α : Type ?u.877436
β : Type u_1
γ : Type u_2
γ₂ : Type ?u.877445
δ : Type ?u.877448
ι : Sort y
s t u : Set α
inst✝¹⁵ : TopologicalSpace α
inst✝¹⁴ : MeasurableSpace α
inst✝¹³ : OpensMeasurableSpace α
inst✝¹² : TopologicalSpace β
inst✝¹¹ : MeasurableSpace β
inst✝¹⁰ : OpensMeasurableSpace β
inst✝⁹ : TopologicalSpace γ
inst✝⁸ : MeasurableSpace γ
inst✝⁷ : BorelSpace γ
inst✝⁶ : TopologicalSpace γ₂
inst✝⁵ : MeasurableSpace γ₂
inst✝⁴ : BorelSpace γ₂
inst✝³ : MeasurableSpace δ
α' : Type ?u.877541
inst✝² : TopologicalSpace α'
inst✝¹ : MeasurableSpace α'
f : β → γ
hf : Continuous f
hf_surj : Function.Surjective f
μ : MeasureTheory.Measure β
inst✝ : Measure.IsOpenPosMeasure μ
U : Set γ
hUo : IsOpen U
hUne : Set.Nonempty U
⊢ ↑↑(Measure.map f μ) U ≠ 0

tactic: exact (hUo.preimage hf).measure_ne_zero μ (hf_surj.nonempty_preimage.mpr hUne)
state_before: α : Type ?u.877436
β : Type u_1
γ : Type u_2
γ₂ : Type ?u.877445
δ : Type ?u.877448
ι : Sort y
s t u : Set α
inst✝¹⁵ : TopologicalSpace α
inst✝¹⁴ : MeasurableSpace α
inst✝¹³ : OpensMeasurableSpace α
inst✝¹² : TopologicalSpace β
inst✝¹¹ : MeasurableSpace β
inst✝¹⁰ : OpensMeasurableSpace β
inst✝⁹ : TopologicalSpace γ
inst✝⁸ : MeasurableSpace γ
inst✝⁷ : BorelSpace γ
inst✝⁶ : TopologicalSpace γ₂
inst✝⁵ : MeasurableSpace γ₂
inst✝⁴ : BorelSpace γ₂
inst✝³ : MeasurableSpace δ
α' : Type ?u.877541
inst✝² : TopologicalSpace α'
inst✝¹ : MeasurableSpace α'
f : β → γ
hf : Continuous f
hf_surj : Function.Surjective f
μ : MeasureTheory.Measure β
inst✝ : Measure.IsOpenPosMeasure μ
U : Set γ
hUo : IsOpen U
hUne : Set.Nonempty U
⊢ ↑↑μ (f ⁻¹' U) ≠ 0
Theorem: Filter.cofinite.limsup_set_eq
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [← cofinite.blimsup_true s, cofinite.blimsup_set_eq, true_and_iff]
state_before: α : Type u_1
β : Type ?u.182390
γ : Type ?u.182393
ι : Type u_2
p : ι → Prop
s : ι → Set α
⊢ limsup s cofinite = {x | Set.Infinite {n | x ∈ s n}}
Theorem: ContinuousLinearMap.le_norm_flip
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rw [mul_right_comm]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_6
𝕜₃ : Type u_2
E : Type u_3
Eₗ : Type ?u.1080046
F : Type u_5
Fₗ : Type ?u.1080052
G : Type u_4
Gₗ : Type ?u.1080058
𝓕 : Type ?u.1080061
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : RingHomIsometric σ₂₃
inst✝ : RingHomIsometric σ₁₃
f : E →SL[σ₁₃] F →SL[σ₂₃] G
x : E
y : F
⊢ ‖↑(↑f x) y‖ ≤ ‖flip f‖ * ‖x‖ * ‖y‖

tactic: exact (flip f).le_op_norm₂ y x
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_6
𝕜₃ : Type u_2
E : Type u_3
Eₗ : Type ?u.1080046
F : Type u_5
Fₗ : Type ?u.1080052
G : Type u_4
Gₗ : Type ?u.1080058
𝓕 : Type ?u.1080061
inst✝¹⁷ : SeminormedAddCommGroup E
inst✝¹⁶ : SeminormedAddCommGroup Eₗ
inst✝¹⁵ : SeminormedAddCommGroup F
inst✝¹⁴ : SeminormedAddCommGroup Fₗ
inst✝¹³ : SeminormedAddCommGroup G
inst✝¹² : SeminormedAddCommGroup Gₗ
inst✝¹¹ : NontriviallyNormedField 𝕜
inst✝¹⁰ : NontriviallyNormedField 𝕜₂
inst✝⁹ : NontriviallyNormedField 𝕜₃
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : NormedSpace 𝕜 Eₗ
inst✝⁶ : NormedSpace 𝕜₂ F
inst✝⁵ : NormedSpace 𝕜 Fₗ
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹ : RingHomIsometric σ₂₃
inst✝ : RingHomIsometric σ₁₃
f : E →SL[σ₁₃] F →SL[σ₂₃] G
x : E
y : F
⊢ ‖↑(↑f x) y‖ ≤ ‖flip f‖ * ‖y‖ * ‖x‖
Theorem: continuous_sup_dom
File: Mathlib/Topology/Order.lean

tactic: simp only [continuous_iff_le_induced, sup_le_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.38234
f : α → β
ι : Sort ?u.38241
t₁ t₂ : TopologicalSpace α
t₃ : TopologicalSpace β
⊢ Continuous f ↔ Continuous f ∧ Continuous f
Theorem: NonUnitalAlgHom.ext_iff
File: Mathlib/Algebra/Hom/NonUnitalAlg.lean

tactic: rintro rfl x
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f g : A →ₙₐ[R] B
⊢ f = g → ∀ (x : A), ↑f x = ↑g x

tactic: rfl
state_before: R : Type u
A : Type v
B : Type w
C : Type w₁
inst✝⁶ : Monoid R
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction R B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction R C
f : A →ₙₐ[R] B
x : A
⊢ ↑f x = ↑f x
Theorem: CategoryTheory.Quotient.lift_map_functor_map
File: Mathlib/CategoryTheory/Quotient.lean

tactic: rw [← NatIso.naturality_1 (lift.isLift r F H)]
state_before: C : Type u_2
inst✝¹ : Category C
r : HomRel C
D : Type u_4
inst✝ : Category D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
X Y : C
f : X ⟶ Y
⊢ (lift r F H).map ((functor r).map f) = F.map f

tactic: dsimp
state_before: C : Type u_2
inst✝¹ : Category C
r : HomRel C
D : Type u_4
inst✝ : Category D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
X Y : C
f : X ⟶ Y
⊢ (lift r F H).map ((functor r).map f) =
    (lift.isLift r F H).inv.app X ≫ (functor r ⋙ lift r F H).map f ≫ (lift.isLift r F H).hom.app Y

tactic: simp
state_before: C : Type u_2
inst✝¹ : Category C
r : HomRel C
D : Type u_4
inst✝ : Category D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
X Y : C
f : X ⟶ Y
⊢ Quot.liftOn (Quot.mk (CompClosure r) f) (fun f => F.map f)
      (_ :
        ∀ (a b : ((functor r).obj X).as ⟶ ((functor r).obj Y).as),
          CompClosure r a b → (fun f => F.map f) a = (fun f => F.map f) b) =
    𝟙 (F.obj X) ≫
      Quot.liftOn (Quot.mk (CompClosure r) f) (fun f => F.map f)
          (_ :
            ∀ (a b : ((functor r).obj X).as ⟶ ((functor r).obj Y).as),
              CompClosure r a b → (fun f => F.map f) a = (fun f => F.map f) b) ≫
        𝟙 (F.obj Y)
Theorem: Irrational.of_neg
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [cast_neg, hx]
state_before: q✝ : ℚ
x y : ℝ
h : Irrational (-x)
x✝ : x ∈ Set.range Rat.cast
q : ℚ
hx : ↑q = x
⊢ ↑(-q) = -x
Theorem: Basis.coePiBasisFun.toMatrix_eq_transpose
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext (M i j)
state_before: ι : Type u_1
ι' : Type ?u.96253
κ : Type ?u.96256
κ' : Type ?u.96259
R : Type u_2
M : Type ?u.96265
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
R₂ : Type ?u.96452
M₂ : Type ?u.96455
inst✝³ : CommRing R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
inst✝ : Fintype ι
⊢ toMatrix (Pi.basisFun R ι) = transpose

tactic: rfl
state_before: case h.a.h
ι : Type u_1
ι' : Type ?u.96253
κ : Type ?u.96256
κ' : Type ?u.96259
R : Type u_2
M✝ : Type ?u.96265
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M✝
inst✝⁴ : Module R M✝
R₂ : Type ?u.96452
M₂ : Type ?u.96455
inst✝³ : CommRing R₂
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
e : Basis ι R M✝
v : ι' → M✝
i✝ : ι
j✝ : ι'
inst✝ : Fintype ι
M : ι → ι → R
i j : ι
⊢ toMatrix (Pi.basisFun R ι) M i j = Mᵀ i j
Theorem: Matrix.UnitaryGroup.toGL_one
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

tactic: simp only [coe_toGL, toLin'_one]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ ↑(toGL 1) = ↑1

tactic: rfl
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ LinearMap.id = ↑1
Theorem: Finsupp.neLocus_comm
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: simp_rw [neLocus, Finset.union_comm, ne_comm]
state_before: α : Type u_1
M : Type ?u.4833
N : Type u_2
P : Type ?u.4839
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
⊢ neLocus f g = neLocus g f
Theorem: List.dedup_cons_of_mem'
File: Mathlib/Data/List/Dedup.lean

tactic: simpa only [forall_mem_ne, not_not] using h
state_before: α : Type u
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ dedup l
⊢ ¬∀ (b : α), b ∈ pwFilter (fun x x_1 => x ≠ x_1) l → a ≠ b
Theorem: orderOf_eq_prime
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rwa [IsFixedPt, mul_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
p : ℕ
hp : Fact (Nat.Prime p)
hg : x ^ p = 1
hg1 : x ≠ 1
⊢ ¬IsFixedPt (fun x_1 => x * x_1) 1
Theorem: UniformSpace.Completion.dist_self
File: Mathlib/Topology/MetricSpace/Completion.lean

tactic: refine' induction_on x _ _
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ dist x x = 0

tactic: refine' isClosed_eq _ continuous_const
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ IsClosed {a | dist a a = 0}

tactic: exact Completion.continuous_dist continuous_id continuous_id
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ Continuous fun a => dist a a

tactic: intro a
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
⊢ ∀ (a : α), dist (↑α a) (↑α a) = 0

tactic: rw [Completion.dist_eq, dist_self]
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x : Completion α
a : α
⊢ dist (↑α a) (↑α a) = 0
Theorem: contDiff_pi
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← contDiffOn_univ, contDiffOn_pi]
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type ?u.1601042
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
ι : Type u_2
ι' : Type ?u.1604523
inst✝³ : Fintype ι
inst✝² : Fintype ι'
F' : ι → Type u_3
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
p' : (i : ι) → E → FormalMultilinearSeries 𝕜 E (F' i)
Φ : E → (i : ι) → F' i
P' : E → FormalMultilinearSeries 𝕜 E ((i : ι) → F' i)
⊢ ContDiff 𝕜 n Φ ↔ ∀ (i : ι), ContDiff 𝕜 n fun x => Φ x i
Theorem: Finset.mulEtransformLeft.fst_mul_snd_subset
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: refine' inter_mul_union_subset_union.trans (union_subset Subset.rfl _)
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ (mulEtransformLeft e x).fst * (mulEtransformLeft e x).snd ⊆ x.fst * x.snd

tactic: rw [op_smul_finset_mul_eq_mul_smul_finset, smul_inv_smul]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ op e • x.fst * e⁻¹ • x.snd ⊆ x.fst * x.snd
Theorem: Submodule.lt_of_le_of_finrank_lt_finrank
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [h]
state_before: K : Type u
V : Type v
inst✝⁴ : Ring K
inst✝³ : AddCommGroup V
inst✝² : Module K V
V₂ : Type v'
inst✝¹ : AddCommGroup V₂
inst✝ : Module K V₂
s t : Submodule K V
le : s ≤ t
lt : finrank K { x // x ∈ s } < finrank K { x // x ∈ t }
h : s = t
⊢ finrank K { x // x ∈ s } = finrank K { x // x ∈ t }