tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearMap.norm_map_tail_le
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: ring
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
m : (i : Fin (Nat.succ n)) → Ei i
⊢ ‖f‖ * ‖m 0‖ * ∏ i : Fin n, ‖tail m i‖ = ‖f‖ * (‖m 0‖ * ∏ i : Fin n, ‖tail m i‖)

tactic: rw [prod_univ_succ]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
m : (i : Fin (Nat.succ n)) → Ei i
⊢ ‖f‖ * (‖m 0‖ * ∏ i : Fin n, ‖tail m i‖) = ‖f‖ * ∏ i : Fin (Nat.succ n), ‖m i‖

tactic: rfl
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i => Ei (succ i)) G
m : (i : Fin (Nat.succ n)) → Ei i
⊢ ‖f‖ * (‖m 0‖ * ∏ i : Fin n, ‖tail m i‖) = ‖f‖ * (‖m 0‖ * ∏ i : Fin n, ‖m (succ i)‖)
Theorem: Multiset.prod_induction
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [prod_eq_foldr]
state_before: ι : Type ?u.79714
α : Type u_1
β : Type ?u.79720
γ : Type ?u.79723
inst✝ : CommMonoid α
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
s : Multiset α
p_mul : ∀ (a b : α), p a → p b → p (a * b)
p_one : p 1
p_s : ∀ (a : α), a ∈ s → p a
⊢ p (prod s)

tactic: simp [mul_left_comm]
state_before: ι : Type ?u.79714
α : Type u_1
β : Type ?u.79720
γ : Type ?u.79723
inst✝ : CommMonoid α
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
p : α → Prop
s : Multiset α
p_mul : ∀ (a b : α), p a → p b → p (a * b)
p_one : p 1
p_s : ∀ (a : α), a ∈ s → p a
x y z : α
⊢ (fun x x_1 => x * x_1) x ((fun x x_1 => x * x_1) y z) = (fun x x_1 => x * x_1) y ((fun x x_1 => x * x_1) x z)
Theorem: Set.Ioc_eq_empty_iff
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← not_nonempty_iff_eq_empty, not_iff_not, nonempty_Ioc]
state_before: α : Type u_1
β : Type ?u.27904
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b = ∅ ↔ ¬a < b
Theorem: Int.add_lt_of_lt_neg_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_left h a
state_before: a b c : Int
h : b < -a + c
⊢ a + b < c

tactic: rwa [Int.add_neg_cancel_left] at h
state_before: a b c : Int
h✝ : b < -a + c
h : a + b < a + (-a + c)
⊢ a + b < c
Theorem: Submodule.map_comap_subtype
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rintro ⟨⟨_, h₁⟩, h₂, rfl⟩
state_before: F : Type ?u.932648
R : Type u_2
R₁ : Type ?u.932056
R₂ : Type ?u.932059
R₃ : Type ?u.932062
R₄ : Type ?u.932065
S : Type ?u.932068
K : Type ?u.932071
K₂ : Type ?u.932074
M : Type u_1
M' : Type ?u.932080
M₁ : Type ?u.932083
M₂ : Type ?u.932086
M₃ : Type ?u.932089
M₄ : Type ?u.932092
N : Type ?u.932095
N₂ : Type ?u.932098
ι : Type ?u.932101
V : Type ?u.932104
V₂ : Type ?u.932107
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R M
inst✝⁵ : Module R M'
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝² : RingHomInvPair σ₁₂ σ₂₁
inst✝¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x✝ y : M
sc : SemilinearMapClass F σ₁₂ M M₂
x : M
⊢ x ∈ map (Submodule.subtype p) (comap (Submodule.subtype p) p') → x ∈ p ⊓ p'

tactic: exact ⟨h₁, h₂⟩
state_before: case intro.mk.intro
F : Type ?u.932648
R : Type u_2
R₁ : Type ?u.932056
R₂ : Type ?u.932059
R₃ : Type ?u.932062
R₄ : Type ?u.932065
S : Type ?u.932068
K : Type ?u.932071
K₂ : Type ?u.932074
M : Type u_1
M' : Type ?u.932080
M₁ : Type ?u.932083
M₂ : Type ?u.932086
M₃ : Type ?u.932089
M₄ : Type ?u.932092
N : Type ?u.932095
N₂ : Type ?u.932098
ι : Type ?u.932101
V : Type ?u.932104
V₂ : Type ?u.932107
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : Module R M
inst✝⁵ : Module R M'
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
σ₂₁ : R₂ →+* R
inst✝² : RingHomInvPair σ₁₂ σ₂₁
inst✝¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
p p' : Submodule R M
q q' : Submodule R₂ M₂
q₁ q₁' : Submodule R M'
r : R
x y : M
sc : SemilinearMapClass F σ₁₂ M M₂
val✝ : M
h₁ : val✝ ∈ p
h₂ : { val := val✝, property := h₁ } ∈ ↑(comap (Submodule.subtype p) p')
⊢ ↑(Submodule.subtype p) { val := val✝, property := h₁ } ∈ p ⊓ p'
Theorem: Complex.range_exp_mul_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: ext x
state_before: ⊢ (Set.range fun x => exp (↑x * I)) = Metric.sphere 0 1

tactic: simp only [mem_sphere_zero_iff_norm, norm_eq_abs, abs_eq_one_iff, Set.mem_range]
state_before: case h
x : ℂ
⊢ (x ∈ Set.range fun x => exp (↑x * I)) ↔ x ∈ Metric.sphere 0 1
Theorem: PNat.recOn_succ
File: Mathlib/Data/PNat/Basic.lean

tactic: cases' n with n h
state_before: n : ℕ+
p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
⊢ recOn (n + 1) p1 hp = hp n (recOn n p1 hp)

tactic: cases n <;> [exact absurd h (by decide); rfl]
state_before: case mk
p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
n : ℕ
h : 0 < n
⊢ recOn ({ val := n, property := h } + 1) p1 hp =
    hp { val := n, property := h } (recOn { val := n, property := h } p1 hp)

tactic: decide
state_before: p : ℕ+ → Sort u_1
p1 : p 1
hp : (n : ℕ+) → p n → p (n + 1)
h : 0 < zero
⊢ ¬0 < zero
Theorem: factor_orderIso_map_one_eq_bot
File: Mathlib/RingTheory/ChainOfDivisors.lean

tactic: letI : OrderBot { l : Associates M // l ≤ m } := Subtype.orderBot bot_le
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m : Associates M
n : Associates N
d : { l // l ≤ m } ≃o { l // l ≤ n }
⊢ ↑(↑d { val := 1, property := (_ : 1 ∣ m) }) = 1

tactic: letI : OrderBot { l : Associates N // l ≤ n } := Subtype.orderBot bot_le
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m : Associates M
n : Associates N
d : { l // l ≤ m } ≃o { l // l ≤ n }
this : OrderBot { l // l ≤ m } := Subtype.orderBot (_ : ⊥ ≤ m)
⊢ ↑(↑d { val := 1, property := (_ : 1 ∣ m) }) = 1

tactic: simp only [← Associates.bot_eq_one, Subtype.mk_bot, bot_le, Subtype.coe_eq_bot_iff]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m : Associates M
n : Associates N
d : { l // l ≤ m } ≃o { l // l ≤ n }
this✝ : OrderBot { l // l ≤ m } := Subtype.orderBot (_ : ⊥ ≤ m)
this : OrderBot { l // l ≤ n } := Subtype.orderBot (_ : ⊥ ≤ n)
⊢ ↑(↑d { val := 1, property := (_ : 1 ∣ m) }) = 1

tactic: letI : BotHomClass ({ l // l ≤ m } ≃o { l // l ≤ n }) _ _ := OrderIsoClass.toBotHomClass
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m : Associates M
n : Associates N
d : { l // l ≤ m } ≃o { l // l ≤ n }
this✝ : OrderBot { l // l ≤ m } := Subtype.orderBot (_ : ⊥ ≤ m)
this : OrderBot { l // l ≤ n } := Subtype.orderBot (_ : ⊥ ≤ n)
⊢ ↑d ⊥ = ⊥

tactic: exact map_bot d
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m : Associates M
n : Associates N
d : { l // l ≤ m } ≃o { l // l ≤ n }
this✝¹ : OrderBot { l // l ≤ m } := Subtype.orderBot (_ : ⊥ ≤ m)
this✝ : OrderBot { l // l ≤ n } := Subtype.orderBot (_ : ⊥ ≤ n)
this : BotHomClass ({ l // l ≤ m } ≃o { l // l ≤ n }) { l // l ≤ m } { l // l ≤ n } := OrderIsoClass.toBotHomClass
⊢ ↑d ⊥ = ⊥
Theorem: Nat.factorization_mul_apply_of_coprime
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp only [← factors_count_eq, perm_iff_count.mp (perm_factors_mul_of_coprime hab), count_append]
state_before: p a b : ℕ
hab : coprime a b
⊢ ↑(factorization (a * b)) p = ↑(factorization a) p + ↑(factorization b) p
Theorem: ENNReal.toReal_eq_toReal_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [ENNReal.toReal, NNReal.coe_eq, toNNReal_eq_toNNReal_iff]
state_before: α : Type ?u.32519
β : Type ?u.32522
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
⊢ ENNReal.toReal x = ENNReal.toReal y ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0
Theorem: PadicInt.denseRange_int_cast
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: intro x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ DenseRange Int.cast

tactic: refine DenseRange.induction_on denseRange_nat_cast x ?_ ?_
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ closure (Set.range Int.cast)

tactic: exact isClosed_closure
state_before: case refine_1
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ IsClosed {b | b ∈ closure (Set.range Int.cast)}

tactic: intro a
state_before: case refine_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (a : ℕ), ↑a ∈ closure (Set.range Int.cast)

tactic: apply subset_closure
state_before: case refine_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
a : ℕ
⊢ ↑a ∈ closure (Set.range Int.cast)

tactic: exact Set.mem_range_self _
state_before: case refine_2.a
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
a : ℕ
⊢ ↑a ∈ Set.range Int.cast
Theorem: le_div_iff_mul_le
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a ≤ c / b ↔ a * b ≤ c
Theorem: openSegment_same
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simpa only [← add_smul, mem_singleton_iff, hab, one_smul, eq_comm] using hz
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.51667
G : Type ?u.51670
ι : Type ?u.51673
π : ι → Type ?u.51678
inst✝⁷ : OrderedRing 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
x z : E
x✝ : z ∈ openSegment 𝕜 x x
a b : 𝕜
w✝¹ : 0 < a
w✝ : 0 < b
hab : a + b = 1
hz : a • x + b • x = z
⊢ z ∈ {x}

tactic: obtain ⟨a, ha₀, ha₁⟩ := DenselyOrdered.dense (0 : 𝕜) 1 zero_lt_one
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.51667
G : Type ?u.51670
ι : Type ?u.51673
π : ι → Type ?u.51678
inst✝⁷ : OrderedRing 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
x z : E
h : z = x
⊢ z ∈ openSegment 𝕜 x x

tactic: refine' ⟨a, 1 - a, ha₀, sub_pos_of_lt ha₁, add_sub_cancel'_right _ _, _⟩
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.51667
G : Type ?u.51670
ι : Type ?u.51673
π : ι → Type ?u.51678
inst✝⁷ : OrderedRing 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
x z : E
h : z = x
a : 𝕜
ha₀ : 0 < a
ha₁ : a < 1
⊢ z ∈ openSegment 𝕜 x x

tactic: rw [← add_smul, add_sub_cancel'_right, one_smul, h]
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.51667
G : Type ?u.51670
ι : Type ?u.51673
π : ι → Type ?u.51678
inst✝⁷ : OrderedRing 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : Nontrivial 𝕜
inst✝ : DenselyOrdered 𝕜
x z : E
h : z = x
a : 𝕜
ha₀ : 0 < a
ha₁ : a < 1
⊢ a • x + (1 - a) • x = z
Theorem: Num.sub_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [ofZNum_toNat, cast_sub', ← to_nat_to_int, ← to_nat_to_int, Int.toNat_sub]
state_before: α : Type ?u.886342
m n : Num
⊢ ↑(ofZNum (sub' m n)) = ↑m - ↑n
Theorem: Int.mul_ediv_cancel'
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.ediv_mul_cancel H]
state_before: a b : Int
H : a ∣ b
⊢ a * (b / a) = b
Theorem: ConjClasses.map_surjective
File: Mathlib/Algebra/Group/Conj.lean

tactic: intro b
state_before: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
⊢ Function.Surjective (map f)

tactic: obtain ⟨b, rfl⟩ := ConjClasses.mk_surjective b
state_before: α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
b : ConjClasses β
⊢ ∃ a, map f a = b

tactic: obtain ⟨a, rfl⟩ := hf b
state_before: case intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
b : β
⊢ ∃ a, map f a = ConjClasses.mk b

tactic: exact ⟨ConjClasses.mk a, rfl⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : Monoid α
inst✝ : Monoid β
f : α →* β
hf : Function.Surjective ↑f
a : α
⊢ ∃ a_1, map f a_1 = ConjClasses.mk (↑f a)
Theorem: uniformity_le_symm
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [map_swap_eq_comap_swap]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.49429
inst✝ : UniformSpace α
⊢ 𝓤 α ≤ Prod.swap <$> 𝓤 α

tactic: exact tendsto_swap_uniformity.le_comap
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.49429
inst✝ : UniformSpace α
⊢ 𝓤 α ≤ comap Prod.swap (𝓤 α)
Theorem: mem_rightCoset_iff
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [Eq.symm, hb]
state_before: α : Type u_1
inst✝ : Group α
s : Set α
x a : α
x✝ : x ∈ s *r a
b : α
hb : b ∈ s
Eq : (fun x => x * a) b = x
⊢ x * a⁻¹ ∈ s

tactic: simp
state_before: α : Type u_1
inst✝ : Group α
s : Set α
x a : α
h : x * a⁻¹ ∈ s
⊢ (fun x => x * a) (x * a⁻¹) = x
Theorem: Nat.add_mul_div_left
File: Std/Data/Nat/Lemmas.lean

tactic: induction z with
| zero => rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero]
| succ z ih => rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih]; rfl
state_before: x z y : Nat
H : 0 < y
⊢ (x + y * z) / y = x / y + z

tactic: rw [Nat.mul_zero, Nat.add_zero, Nat.add_zero]
state_before: case zero
x y : Nat
H : 0 < y
⊢ (x + y * zero) / y = x / y + zero

tactic: rw [mul_succ, ← Nat.add_assoc, add_div_right _ H, ih]
state_before: case succ
x y : Nat
H : 0 < y
z : Nat
ih : (x + y * z) / y = x / y + z
⊢ (x + y * succ z) / y = x / y + succ z

tactic: rfl
state_before: case succ
x y : Nat
H : 0 < y
z : Nat
ih : (x + y * z) / y = x / y + z
⊢ succ (x / y + z) = x / y + succ z
Theorem: Ring.DirectLimit.of.zero_exact
File: Mathlib/Algebra/DirectLimit.lean

tactic: rw [restriction_of, dif_pos hixs, lift_of] at hx
state_before: R : Type u
inst✝⁴ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝³ : Preorder ι
G : ι → Type w
inst✝² : (i : ι) → CommRing (G i)
f : (i j : ι) → i ≤ j → G i → G j
f' : (i j : ι) → i ≤ j → G i →+* G j
inst✝¹ : DirectedSystem G fun i j h => ↑(f' i j h)
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
i : ι
x : G i
hix : ↑(of G (fun i j h => ↑(f' i j h)) i) x = 0
this : Nonempty ι
j : ι
s : Set ((i : ι) × G i)
H : ∀ (k : (i : ι) × G i), k ∈ s → k.fst ≤ j
hxs : IsSupported (FreeCommRing.of { fst := i, snd := x }) s
hx :
  ↑(↑lift fun ix => ↑(f' (↑ix).fst j (_ : (↑ix).fst ≤ j)) (↑ix).snd)
      (↑(restriction s) (FreeCommRing.of { fst := i, snd := x })) =
    0
hixs : { fst := i, snd := x } ∈ s
⊢ ↑(f' i j (_ : { fst := i, snd := x }.fst ≤ j)) x = 0

tactic: exact hx
state_before: R : Type u
inst✝⁴ : Ring R
ι : Type v
dec_ι : DecidableEq ι
inst✝³ : Preorder ι
G : ι → Type w
inst✝² : (i : ι) → CommRing (G i)
f : (i j : ι) → i ≤ j → G i → G j
f' : (i j : ι) → i ≤ j → G i →+* G j
inst✝¹ : DirectedSystem G fun i j h => ↑(f' i j h)
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
i : ι
x : G i
hix : ↑(of G (fun i j h => ↑(f' i j h)) i) x = 0
this : Nonempty ι
j : ι
s : Set ((i : ι) × G i)
H : ∀ (k : (i : ι) × G i), k ∈ s → k.fst ≤ j
hxs : IsSupported (FreeCommRing.of { fst := i, snd := x }) s
hixs : { fst := i, snd := x } ∈ s
hx :
  ↑(f' (↑{ val := { fst := i, snd := x }, property := hixs }).fst j
          (_ : (↑{ val := { fst := i, snd := x }, property := hixs }).fst ≤ j))
      (↑{ val := { fst := i, snd := x }, property := hixs }).snd =
    0
⊢ ↑(f' i j (_ : { fst := i, snd := x }.fst ≤ j)) x = 0
Theorem: FreeProduct.ext_hom
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: rw [MonoidHom.comp_apply, MonoidHom.comp_apply, ← of_apply, ← MonoidHom.comp_apply, ←
  MonoidHom.comp_apply, h]
state_before: ι : Type u_2
M : ι → Type u_1
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
f g : FreeProduct M →* N
h : ∀ (i : ι), MonoidHom.comp f of = MonoidHom.comp g of
x✝ : (i : ι) × M i
i : ι
x : M i
⊢ ↑(MonoidHom.comp f (Con.mk' (conGen (Rel M)))) (FreeMonoid.of { fst := i, snd := x }) =
    ↑(MonoidHom.comp g (Con.mk' (conGen (Rel M)))) (FreeMonoid.of { fst := i, snd := x })
Theorem: Real.ennnorm_eq_ofReal
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← ofReal_norm_eq_coe_nnnorm, norm_of_nonneg hr]
state_before: 𝓕 : Type ?u.1108722
𝕜 : Type ?u.1108725
α : Type ?u.1108728
ι : Type ?u.1108731
κ : Type ?u.1108734
E : Type ?u.1108737
F : Type ?u.1108740
G : Type ?u.1108743
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
hr : 0 ≤ r
⊢ ↑‖r‖₊ = ENNReal.ofReal r
Theorem: exists_norm_eq_iInf_of_complete_subspace
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: letI : InnerProductSpace ℝ E := InnerProductSpace.isROrCToReal 𝕜 E
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.246546
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
h : IsComplete ↑K
⊢ ∀ (u : E), ∃ v, v ∈ K ∧ ‖u - v‖ = ⨅ (w : ↑↑K), ‖u - ↑w‖

tactic: letI : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.246546
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
h : IsComplete ↑K
this : InnerProductSpace ℝ E := InnerProductSpace.isROrCToReal 𝕜 E
⊢ ∀ (u : E), ∃ v, v ∈ K ∧ ‖u - v‖ = ⨅ (w : ↑↑K), ‖u - ↑w‖

tactic: let K' : Submodule ℝ E := Submodule.restrictScalars ℝ K
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.246546
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
h : IsComplete ↑K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.isROrCToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
⊢ ∀ (u : E), ∃ v, v ∈ K ∧ ‖u - v‖ = ⨅ (w : ↑↑K), ‖u - ↑w‖

tactic: exact exists_norm_eq_iInf_of_complete_convex ⟨0, K'.zero_mem⟩ h K'.convex
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.246546
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
h : IsComplete ↑K
this✝ : InnerProductSpace ℝ E := InnerProductSpace.isROrCToReal 𝕜 E
this : Module ℝ E := RestrictScalars.module ℝ 𝕜 E
K' : Submodule ℝ E := Submodule.restrictScalars ℝ K
⊢ ∀ (u : E), ∃ v, v ∈ K ∧ ‖u - v‖ = ⨅ (w : ↑↑K), ‖u - ↑w‖
Theorem: WithTop.strictMono_map_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [StrictMono, coe_lt_top]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.99319
δ : Type ?u.99322
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((StrictMono fun a => map f ↑a) ∧ ∀ (x : α), map f ↑x < map f ⊤) ↔ StrictMono f
Theorem: spectrum.smul_mem_smul_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: simp only [mem_iff, not_iff_not, Algebra.algebraMap_eq_smul_one, smul_assoc, ← smul_sub,
  isUnit_smul_iff]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
s : R
r : Rˣ
⊢ r • s ∈ σ (r • a) ↔ s ∈ σ a
Theorem: List.sublists'_eq_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: rw [← sublists'_reverse, reverse_reverse]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublists' l = map reverse (sublists (reverse l))
Theorem: isPiSystem_Icc
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: exact Icc_inter_Icc
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
f : ι → α
g : ι' → α
⊢ ∀ {a₁ b₁ a₂ b₂ : α}, Icc a₁ b₁ ∩ Icc a₂ b₂ = Icc (max a₁ a₂) (min b₁ b₂)
Theorem: CategoryTheory.Iso.unop_op
File: Mathlib/CategoryTheory/Opposites.lean

tactic: (ext; rfl)
state_before: C : Type u₁
inst✝ : Category C
X✝ Y✝ : C
X Y : Cᵒᵖ
f : X ≅ Y
⊢ Iso.op (unop f) = f

tactic: ext
state_before: C : Type u₁
inst✝ : Category C
X✝ Y✝ : C
X Y : Cᵒᵖ
f : X ≅ Y
⊢ Iso.op (unop f) = f

tactic: rfl
state_before: case w
C : Type u₁
inst✝ : Category C
X✝ Y✝ : C
X Y : Cᵒᵖ
f : X ≅ Y
⊢ (Iso.op (unop f)).hom = f.hom
Theorem: SimpleGraph.incidence_other_prop
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: cases' h with he hv
state_before: ι : Sort ?u.150205
𝕜 : Type ?u.150208
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e✝ : Sym2 V
inst✝ : DecidableEq V
v : V
e : Sym2 V
h : e ∈ incidenceSet G v
⊢ otherVertexOfIncident G h ∈ neighborSet G v

tactic: rwa [← Sym2.other_spec' hv, mem_edgeSet] at he
state_before: case intro
ι : Sort ?u.150205
𝕜 : Type ?u.150208
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e✝ : Sym2 V
inst✝ : DecidableEq V
v : V
e : Sym2 V
he : e ∈ edgeSet G
hv : v ∈ e
⊢ otherVertexOfIncident G (_ : e ∈ edgeSet G ∧ v ∈ e) ∈ neighborSet G v
Theorem: Filter.mem_prod_iff_left
File: Mathlib/Order/Filter/Prod.lean

tactic: simp only [mem_prod_iff, prod_subset_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.15041
δ : Type ?u.15044
ι : Sort ?u.15047
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ s ∈ f ×ˢ g ↔ ∃ t, t ∈ f ∧ ∀ᶠ (y : β) in g, ∀ (x : α), x ∈ t → (x, y) ∈ s

tactic: refine exists_congr fun _ => Iff.rfl.and <| Iff.trans ?_ exists_mem_subset_iff
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.15041
δ : Type ?u.15044
ι : Sort ?u.15047
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ (∃ t₁, t₁ ∈ f ∧ ∃ t₂, t₂ ∈ g ∧ ∀ (x : α), x ∈ t₁ → ∀ (y : β), y ∈ t₂ → (x, y) ∈ s) ↔
    ∃ t, t ∈ f ∧ ∀ᶠ (y : β) in g, ∀ (x : α), x ∈ t → (x, y) ∈ s

tactic: exact exists_congr fun _ => Iff.rfl.and forall₂_swap
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.15041
δ : Type ?u.15044
ι : Sort ?u.15047
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
x✝ : Set α
⊢ (∃ t₂, t₂ ∈ g ∧ ∀ (x : α), x ∈ x✝ → ∀ (y : β), y ∈ t₂ → (x, y) ∈ s) ↔
    ∃ t, t ∈ g ∧ t ⊆ {x | (fun y => ∀ (x : α), x ∈ x✝ → (x, y) ∈ s) x}