tasksource/leandojo huggingface dataset:
Theorem: FirstOrder.Language.Theory.isSatisfiable_directed_union_iff
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: refine' ⟨fun h' i => h'.mono (Set.subset_iUnion _ _), fun h' => _⟩
state_before: L : Language
T✝ : Theory L
α : Type w
n : ℕ
T' : Theory L
ι : Type u_1
inst✝ : Nonempty ι
T : ι → Theory L
h : Directed (fun x x_1 => x ⊆ x_1) T
⊢ IsSatisfiable (⋃ (i : ι), T i) ↔ ∀ (i : ι), IsSatisfiable (T i)

tactic: rw [isSatisfiable_iff_isFinitelySatisfiable, IsFinitelySatisfiable]
state_before: L : Language
T✝ : Theory L
α : Type w
n : ℕ
T' : Theory L
ι : Type u_1
inst✝ : Nonempty ι
T : ι → Theory L
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), IsSatisfiable (T i)
⊢ IsSatisfiable (⋃ (i : ι), T i)

tactic: intro T0 hT0
state_before: L : Language
T✝ : Theory L
α : Type w
n : ℕ
T' : Theory L
ι : Type u_1
inst✝ : Nonempty ι
T : ι → Theory L
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), IsSatisfiable (T i)
⊢ ∀ (T0 : Finset (Sentence L)), (↑T0 ⊆ ⋃ (i : ι), T i) → IsSatisfiable ↑T0

tactic: obtain ⟨i, hi⟩ := h.exists_mem_subset_of_finset_subset_biUnion hT0
state_before: L : Language
T✝ : Theory L
α : Type w
n : ℕ
T' : Theory L
ι : Type u_1
inst✝ : Nonempty ι
T : ι → Theory L
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), IsSatisfiable (T i)
T0 : Finset (Sentence L)
hT0 : ↑T0 ⊆ ⋃ (i : ι), T i
⊢ IsSatisfiable ↑T0

tactic: exact (h' i).mono hi
state_before: case intro
L : Language
T✝ : Theory L
α : Type w
n : ℕ
T' : Theory L
ι : Type u_1
inst✝ : Nonempty ι
T : ι → Theory L
h : Directed (fun x x_1 => x ⊆ x_1) T
h' : ∀ (i : ι), IsSatisfiable (T i)
T0 : Finset (Sentence L)
hT0 : ↑T0 ⊆ ⋃ (i : ι), T i
i : ι
hi : ↑T0 ⊆ T i
⊢ IsSatisfiable ↑T0
Theorem: Fin.coe_castPred_le_self
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases i.le_last.eq_or_lt with (rfl | h)
state_before: n m : ℕ
i : Fin (n + 2)
⊢ ↑(castPred i) ≤ ↑i

tactic: simp
state_before: case inl
n m : ℕ
⊢ ↑(castPred (last (n + 1))) ≤ ↑(last (n + 1))

tactic: rw [castPred, predAbove, dif_neg]
state_before: case inr
n m : ℕ
i : Fin (n + 2)
h : i < last (n + 1)
⊢ ↑(castPred i) ≤ ↑i

tactic: simp
state_before: case inr
n m : ℕ
i : Fin (n + 2)
h : i < last (n + 1)
⊢ ↑(castLT i (_ : ↑i < n + 1)) ≤ ↑i

tactic: simpa [lt_iff_val_lt_val, le_iff_val_le_val, lt_succ_iff] using h
state_before: case inr.hnc
n m : ℕ
i : Fin (n + 2)
h : i < last (n + 1)
⊢ ¬↑castSucc (last n) < i
Theorem: inner_self_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [inner_self_eq_norm_sq_to_K, sq_eq_zero_iff, ofReal_eq_zero, norm_eq_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1685745
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ inner x x = 0 ↔ x = 0
Theorem: Nat.totient_mul_of_prime_of_not_dvd
File: Mathlib/Data/Nat/Totient.lean

tactic: rw [totient_mul _, totient_prime hp]
state_before: p n : ℕ
hp : Prime p
h : ¬p ∣ n
⊢ φ (p * n) = (p - 1) * φ n

tactic: simpa [h] using coprime_or_dvd_of_prime hp n
state_before: p n : ℕ
hp : Prime p
h : ¬p ∣ n
⊢ coprime p n
Theorem: Ordnode.Sized.pos
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [h.1]
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
h : Sized (node s l x r)
⊢ 0 < s

tactic: apply Nat.le_add_left
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
h : Sized (node s l x r)
⊢ 0 < size l + size r + 1
Theorem: SimpleGraph.map_singletonSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp only [Relation.Map, Subgraph.map_Adj, singletonSubgraph_Adj, Pi.bot_apply,
  exists_and_left, and_iff_left_iff_imp, IsEmpty.forall_iff, Subgraph.map_verts,
  singletonSubgraph_verts, Set.image_singleton]
state_before: ι : Sort ?u.208301
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
f : G →g G'
v : V
⊢ Subgraph.map f (SimpleGraph.singletonSubgraph G v) = SimpleGraph.singletonSubgraph G' (↑f v)

tactic: exact False.elim
state_before: case Adj.h.h.a
ι : Sort ?u.208301
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
f : G →g G'
v : V
x✝¹ x✝ : W
⊢ ⊥ → ∃ x, ↑f x = x✝¹ ∧ ∃ x, ↑f x = x✝
Theorem: Int.closedEmbedding_coe_rat
File: Mathlib/Topology/Instances/Rat.lean

tactic: simpa using Int.pairwise_one_le_dist
state_before: ⊢ Pairwise fun x y => 1 ≤ dist ↑x ↑y
Theorem: Fin.card_fintypeIoc
File: Mathlib/Data/Fin/Interval.lean

tactic: rw [← card_Ioc, Fintype.card_ofFinset]
state_before: n : ℕ
a b : Fin n
⊢ Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
Theorem: List.Nat.antidiagonal_succ
File: Mathlib/Data/List/NatAntidiagonal.lean

tactic: simp only [antidiagonal, range_succ_eq_map, map_cons, true_and_iff, Nat.add_succ_sub_one,
  add_zero, id.def, eq_self_iff_true, tsub_zero, map_map, Prod.map_mk]
state_before: n : ℕ
⊢ antidiagonal (n + 1) = (0, n + 1) :: map (Prod.map succ id) (antidiagonal n)

tactic: apply congr rfl (congr rfl _)
state_before: n : ℕ
⊢ (0, n + 1) :: (succ 0, n + 1 - succ 0) :: map ((fun i => (i, n + 1 - i)) ∘ succ ∘ succ) (range n) =
    (0, n + 1) :: (succ 0, n) :: map (Prod.map succ id ∘ (fun i => (i, n - i)) ∘ succ) (range n)

tactic: ext
state_before: n : ℕ
⊢ map ((fun i => (i, n + 1 - i)) ∘ succ ∘ succ) (range n) =
    map (Prod.map succ id ∘ (fun i => (i, n - i)) ∘ succ) (range n)

tactic: simp
state_before: case a.a
n n✝ : ℕ
a✝ : ℕ × ℕ
⊢ a✝ ∈ get? (map ((fun i => (i, n + 1 - i)) ∘ succ ∘ succ) (range n)) n✝ ↔
    a✝ ∈ get? (map (Prod.map succ id ∘ (fun i => (i, n - i)) ∘ succ) (range n)) n✝
Theorem: Set.image_sub_const_Ici
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Ici b = Ici (b - a)
Theorem: List.Func.forall_val_of_forall_mem
File: Mathlib/Data/List/Func.lean

tactic: intro h1 h2 n
state_before: α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
⊢ p default → (∀ (x : α), x ∈ as → p x) → ∀ (n : ℕ), p (get n as)

tactic: by_cases h3 : n < as.length
state_before: α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
h1 : p default
h2 : ∀ (x : α), x ∈ as → p x
n : ℕ
⊢ p (get n as)

tactic: apply h2 _ (mem_get_of_le h3)
state_before: case pos
α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
h1 : p default
h2 : ∀ (x : α), x ∈ as → p x
n : ℕ
h3 : n < length as
⊢ p (get n as)

tactic: rw [not_lt] at h3
state_before: case neg
α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
h1 : p default
h2 : ∀ (x : α), x ∈ as → p x
n : ℕ
h3 : ¬n < length as
⊢ p (get n as)

tactic: rw [get_eq_default_of_le _ h3]
state_before: case neg
α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
h1 : p default
h2 : ∀ (x : α), x ∈ as → p x
n : ℕ
h3 : length as ≤ n
⊢ p (get n as)

tactic: apply h1
state_before: case neg
α : Type u
β : Type v
γ : Type w
a : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
as : List α
p : α → Prop
h1 : p default
h2 : ∀ (x : α), x ∈ as → p x
n : ℕ
h3 : length as ≤ n
⊢ p default
Theorem: Even.isSquare_pow
File: Mathlib/Algebra/Parity.lean

tactic: rintro ⟨n, rfl⟩ a
state_before: F : Type ?u.14072
α : Type u_1
β : Type ?u.14078
R : Type ?u.14081
inst✝ : Monoid α
n : ℕ
a : α
⊢ Even n → ∀ (a : α), IsSquare (a ^ n)

tactic: exact ⟨a ^ n, pow_add _ _ _⟩
state_before: case intro
F : Type ?u.14072
α : Type u_1
β : Type ?u.14078
R : Type ?u.14081
inst✝ : Monoid α
a✝ : α
n : ℕ
a : α
⊢ IsSquare (a ^ (n + n))
Theorem: edist_triangle_left
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rw [edist_comm z]
state_before: α : Type u
β : Type v
X : Type ?u.4281
inst✝ : PseudoEMetricSpace α
x y z : α
⊢ edist x y ≤ edist z x + edist z y

tactic: apply edist_triangle
state_before: α : Type u
β : Type v
X : Type ?u.4281
inst✝ : PseudoEMetricSpace α
x y z : α
⊢ edist x y ≤ edist x z + edist z y
Theorem: Finset.sort_perm_toList
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [← Multiset.coe_eq_coe]
state_before: α : Type u_1
β : Type ?u.3947
r : α → α → Prop
inst✝³ : DecidableRel r
inst✝² : IsTrans α r
inst✝¹ : IsAntisymm α r
inst✝ : IsTotal α r
s : Finset α
⊢ sort r s ~ toList s

tactic: simp only [coe_toList, sort_eq]
state_before: α : Type u_1
β : Type ?u.3947
r : α → α → Prop
inst✝³ : DecidableRel r
inst✝² : IsTrans α r
inst✝¹ : IsAntisymm α r
inst✝ : IsTotal α r
s : Finset α
⊢ ↑(sort r s) = ↑(toList s)
Theorem: Complex.dist_conj_comm
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [← dist_conj_conj, conj_conj]
state_before: E : Type ?u.548925
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
⊢ dist (↑(starRingEnd ℂ) z) w = dist z (↑(starRingEnd ℂ) w)
Theorem: fderiv_const_add
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [add_comm c, fderiv_add_const]
state_before: 𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.289578
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.289673
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ fderiv 𝕜 (fun y => c + f y) x = fderiv 𝕜 f x
Theorem: Submonoid.mem_sup_right
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rw [←SetLike.le_def]
state_before: M : Type u_1
A : Type ?u.44116
B : Type ?u.44119
inst✝ : MulOneClass M
S T : Submonoid M
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T

tactic: exact le_sup_right
state_before: M : Type u_1
A : Type ?u.44116
B : Type ?u.44119
inst✝ : MulOneClass M
S T : Submonoid M
⊢ T ≤ S ⊔ T
Theorem: Polynomial.separable_of_subsingleton
File: Mathlib/FieldTheory/Separable.lean

tactic: simp [Separable, IsCoprime]
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Subsingleton R
f : R[X]
⊢ Separable f
Theorem: EMetric.countable_closure_of_compact
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: rcases subset_countable_closure_of_compact hs with ⟨t, hts, htc, hsub⟩
state_before: α : Type u
β : Type v
X : Type ?u.313712
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
hs : IsCompact s
⊢ ∃ t, t ⊆ s ∧ Set.Countable t ∧ s = closure t

tactic: exact ⟨t, hts, htc, hsub.antisymm (closure_minimal hts hs.isClosed)⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type ?u.313712
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
hs : IsCompact s
t : Set γ
hts : t ⊆ s
htc : Set.Countable t
hsub : s ⊆ closure t
⊢ ∃ t, t ⊆ s ∧ Set.Countable t ∧ s = closure t
Theorem: inv_mul_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.31497
G : Type ?u.31500
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a⁻¹ * b = b / a
Theorem: IsFractionRing.div_surjective
File: Mathlib/RingTheory/Localization/FractionRing.lean

tactic: rwa [mk'_eq_div] at h
state_before: R : Type ?u.139727
inst✝¹¹ : CommRing R
M : Submonoid R
S : Type ?u.139919
inst✝¹⁰ : CommRing S
inst✝⁹ : Algebra R S
P : Type ?u.140156
inst✝⁸ : CommRing P
A : Type u_1
inst✝⁷ : CommRing A
inst✝⁶ : IsDomain A
K : Type u_2
B : Type ?u.140339
inst✝⁵ : CommRing B
inst✝⁴ : IsDomain B
inst✝³ : Field K
L : Type ?u.140516
inst✝² : Field L
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
g : A →+* L
z : K
x y : A
hy : y ∈ nonZeroDivisors A
h : mk' K x { val := y, property := hy } = z
⊢ ↑(algebraMap A K) x / ↑(algebraMap A K) y = z
Theorem: Fin.val_bit0
File: Mathlib/Data/Fin/Basic.lean

tactic: cases k
state_before: n✝ m n : ℕ
k : Fin n
⊢ ↑(bit0 k) = bit0 ↑k % n

tactic: rfl
state_before: case mk
n✝ m n val✝ : ℕ
isLt✝ : val✝ < n
⊢ ↑(bit0 { val := val✝, isLt := isLt✝ }) = bit0 ↑{ val := val✝, isLt := isLt✝ } % n
Theorem: TopologicalSpace.IsSeparable.union
File: Mathlib/Topology/Bases.lean

tactic: rcases hs with ⟨cs, cs_count, hcs⟩
state_before: α : Type u
t : TopologicalSpace α
s u : Set α
hs : IsSeparable s
hu : IsSeparable u
⊢ IsSeparable (s ∪ u)

tactic: rcases hu with ⟨cu, cu_count, hcu⟩
state_before: case intro.intro
α : Type u
t : TopologicalSpace α
s u : Set α
hu : IsSeparable u
cs : Set α
cs_count : Set.Countable cs
hcs : s ⊆ closure cs
⊢ IsSeparable (s ∪ u)

tactic: refine' ⟨cs ∪ cu, cs_count.union cu_count, _⟩
state_before: case intro.intro.intro.intro
α : Type u
t : TopologicalSpace α
s u cs : Set α
cs_count : Set.Countable cs
hcs : s ⊆ closure cs
cu : Set α
cu_count : Set.Countable cu
hcu : u ⊆ closure cu
⊢ IsSeparable (s ∪ u)

tactic: exact
  union_subset (hcs.trans (closure_mono (subset_union_left _ _)))
    (hcu.trans (closure_mono (subset_union_right _ _)))
state_before: case intro.intro.intro.intro
α : Type u
t : TopologicalSpace α
s u cs : Set α
cs_count : Set.Countable cs
hcs : s ⊆ closure cs
cu : Set α
cu_count : Set.Countable cu
hcu : u ⊆ closure cu
⊢ s ∪ u ⊆ closure (cs ∪ cu)
Theorem: Real.pi_le_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: norm_num
state_before: ⊢ 0 < 2

tactic: norm_num
state_before: ⊢ 2 = 4 / 2
Theorem: gramSchmidtNormed_unit_length'
File: Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean

tactic: rw [gramSchmidtNormed] at *
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
n : ι
hn : gramSchmidtNormed 𝕜 f n ≠ 0
⊢ ‖gramSchmidtNormed 𝕜 f n‖ = 1

tactic: rw [norm_smul_inv_norm]
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
n : ι
hn : (↑‖gramSchmidt 𝕜 f n‖)⁻¹ • gramSchmidt 𝕜 f n ≠ 0
⊢ ‖(↑‖gramSchmidt 𝕜 f n‖)⁻¹ • gramSchmidt 𝕜 f n‖ = 1

tactic: simpa using hn
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : InnerProductSpace 𝕜 E
ι : Type u_3
inst✝² : LinearOrder ι
inst✝¹ : LocallyFiniteOrderBot ι
inst✝ : IsWellOrder ι fun x x_1 => x < x_1
f : ι → E
n : ι
hn : (↑‖gramSchmidt 𝕜 f n‖)⁻¹ • gramSchmidt 𝕜 f n ≠ 0
⊢ gramSchmidt 𝕜 f n ≠ 0
Theorem: isClosed_sigma_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp only [← isOpen_compl_iff, isOpen_sigma_iff, preimage_compl]
state_before: α : Type u
β : Type v
γ : Type ?u.514368
δ : Type ?u.514371
ε : Type ?u.514374
ζ : Type ?u.514377
ι : Type u_2
κ : Type ?u.514383
σ : ι → Type u_1
τ : κ → Type ?u.514393
inst✝² : (i : ι) → TopologicalSpace (σ i)
inst✝¹ : (k : κ) → TopologicalSpace (τ k)
inst✝ : TopologicalSpace α
s : Set (Sigma σ)
⊢ IsClosed s ↔ ∀ (i : ι), IsClosed (Sigma.mk i ⁻¹' s)
Theorem: MeasureTheory.measure_setOf_frequently_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simpa only [limsup_eq_iInf_iSup_of_nat, frequently_atTop, ← bex_def, setOf_forall,
  setOf_exists] using measure_limsup_eq_zero hp
state_before: α : Type u_1
β : Type ?u.590790
γ : Type ?u.590793
δ : Type ?u.590796
ι : Type ?u.590799
R : Type ?u.590802
R' : Type ?u.590805
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
p : ℕ → α → Prop
hp : (∑' (i : ℕ), ↑↑μ {x | p i x}) ≠ ⊤
⊢ ↑↑μ {x | ∃ᶠ (n : ℕ) in atTop, p n x} = 0
Theorem: MeasureTheory.OuterMeasure.trim_le_trim_iff
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [trim_eq _ hs]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
s : Set α
hs : MeasurableSet s
⊢ ↑(trim m₁) s ≤ ↑m₂ s ↔ ↑m₁ s ≤ ↑m₂ s
Theorem: Set.diag_image
File: Mathlib/Data/Set/Prod.lean

tactic: ext x
state_before: α : Type u_1
s✝ t s : Set α
⊢ (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s

tactic: constructor
state_before: case h
α : Type u_1
s✝ t s : Set α
x : α × α
⊢ x ∈ (fun x => (x, x)) '' s ↔ x ∈ diagonal α ∩ s ×ˢ s

tactic: rintro ⟨x, hx, rfl⟩
state_before: case h.mp
α : Type u_1
s✝ t s : Set α
x : α × α
⊢ x ∈ (fun x => (x, x)) '' s → x ∈ diagonal α ∩ s ×ˢ s

tactic: exact ⟨rfl, hx, hx⟩
state_before: case h.mp.intro.intro
α : Type u_1
s✝ t s : Set α
x : α
hx : x ∈ s
⊢ (fun x => (x, x)) x ∈ diagonal α ∩ s ×ˢ s

tactic: obtain ⟨x, y⟩ := x
state_before: case h.mpr
α : Type u_1
s✝ t s : Set α
x : α × α
⊢ x ∈ diagonal α ∩ s ×ˢ s → x ∈ (fun x => (x, x)) '' s

tactic: rintro ⟨rfl : x = y, h2x⟩
state_before: case h.mpr.mk
α : Type u_1
s✝ t s : Set α
x y : α
⊢ (x, y) ∈ diagonal α ∩ s ×ˢ s → (x, y) ∈ (fun x => (x, x)) '' s

tactic: exact mem_image_of_mem _ h2x.1
state_before: case h.mpr.mk.intro
α : Type u_1
s✝ t s : Set α
x : α
h2x : (x, x) ∈ s ×ˢ s
⊢ (x, x) ∈ (fun x => (x, x)) '' s
Theorem: PiNat.cylinder_zero
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: simp [cylinder_eq_pi]
state_before: E : ℕ → Type u_1
x : (n : ℕ) → E n
⊢ cylinder x 0 = univ
Theorem: Lagrange.basis_pair_right
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [pair_comm]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {i, j} v j = basisDivisor (v j) (v i)

tactic: exact basis_pair_left hij.symm
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {j, i} v j = basisDivisor (v j) (v i)
Theorem: SeminormFamily.basisSets_nonempty
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: let i := Classical.arbitrary ι
state_before: 𝕜 : Type u_3
𝕜₂ : Type ?u.18792
𝕝 : Type ?u.18795
𝕝₂ : Type ?u.18798
E : Type u_2
F : Type ?u.18804
G : Type ?u.18807
ι : Type u_1
ι' : Type ?u.18813
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
⊢ Set.Nonempty (basisSets p)

tactic: refine' nonempty_def.mpr ⟨(p i).ball 0 1, _⟩
state_before: 𝕜 : Type u_3
𝕜₂ : Type ?u.18792
𝕝 : Type ?u.18795
𝕝₂ : Type ?u.18798
E : Type u_2
F : Type ?u.18804
G : Type ?u.18807
ι : Type u_1
ι' : Type ?u.18813
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
i : ι := Classical.arbitrary ι
⊢ Set.Nonempty (basisSets p)

tactic: exact p.basisSets_singleton_mem i zero_lt_one
state_before: 𝕜 : Type u_3
𝕜₂ : Type ?u.18792
𝕝 : Type ?u.18795
𝕝₂ : Type ?u.18798
E : Type u_2
F : Type ?u.18804
G : Type ?u.18807
ι : Type u_1
ι' : Type ?u.18813
inst✝³ : NormedField 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
inst✝ : Nonempty ι
i : ι := Classical.arbitrary ι
⊢ ball (p i) 0 1 ∈ basisSets p
Theorem: Padic.valuation_map_mul
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have h_norm : ‖x * y‖ = ‖x‖ * ‖y‖ := norm_mul x y
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
⊢ valuation (x * y) = valuation x + valuation y

tactic: have hp_ne_one : (p : ℝ) ≠ 1 := by
  rw [← Nat.cast_one, Ne.def, Nat.cast_inj]
  exact Nat.Prime.ne_one hp.elim
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
⊢ valuation (x * y) = valuation x + valuation y

tactic: have hp_pos : (0 : ℝ) < p := by
  rw [← Nat.cast_zero, Nat.cast_lt]
  exact Nat.Prime.pos hp.elim
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
hp_ne_one : ↑p ≠ 1
⊢ valuation (x * y) = valuation x + valuation y

tactic: rw [norm_eq_pow_val hx, norm_eq_pow_val hy, norm_eq_pow_val (mul_ne_zero hx hy), ←
  zpow_add₀ (ne_of_gt hp_pos), zpow_inj hp_pos hp_ne_one, ← neg_add, neg_inj] at h_norm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
hp_ne_one : ↑p ≠ 1
hp_pos : 0 < ↑p
⊢ valuation (x * y) = valuation x + valuation y

tactic: exact h_norm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : valuation (x * y) = valuation x + valuation y
hp_ne_one : ↑p ≠ 1
hp_pos : 0 < ↑p
⊢ valuation (x * y) = valuation x + valuation y

tactic: rw [← Nat.cast_one, Ne.def, Nat.cast_inj]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
⊢ ↑p ≠ 1

tactic: exact Nat.Prime.ne_one hp.elim
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
⊢ ¬p = 1

tactic: rw [← Nat.cast_zero, Nat.cast_lt]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
hp_ne_one : ↑p ≠ 1
⊢ 0 < ↑p

tactic: exact Nat.Prime.pos hp.elim
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x ≠ 0
hy : y ≠ 0
h_norm : ‖x * y‖ = ‖x‖ * ‖y‖
hp_ne_one : ↑p ≠ 1
⊢ 0 < p
Theorem: Computation.mem_map
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← bind_pure]
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ map f s

tactic: apply mem_bind m
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ bind s (pure ∘ f)

tactic: apply ret_mem
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
s : Computation α
m : a ∈ s
⊢ f a ∈ (pure ∘ f) a
Theorem: Qpf.supp_eq_of_isUniform
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: ext u
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ supp (abs { fst := a, snd := f }) = f '' univ

tactic: rw [mem_supp]
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ u ∈ supp (abs { fst := a, snd := f }) ↔ u ∈ f '' univ

tactic: constructor
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ (∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ) ↔
    u ∈ f '' univ

tactic: intro h' a' f' e
state_before: case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ u ∈ f '' univ →
    ∀ (a_2 : (P F).A) (f_1 : PFunctor.B (P F) a_2 → α),
      abs { fst := a_2, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ

tactic: rw [← h _ _ _ _ e.symm]
state_before: case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' : u ∈ f '' univ
a' : (P F).A
f' : PFunctor.B (P F) a' → α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f' '' univ

tactic: apply h'
state_before: case h.mpr
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' : u ∈ f '' univ
a' : (P F).A
f' : PFunctor.B (P F) a' → α
e : abs { fst := a', snd := f' } = abs { fst := a, snd := f }
⊢ u ∈ f '' univ

tactic: intro h'
state_before: case h.mp
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
⊢ (∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
      abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ) →
    u ∈ f '' univ

tactic: apply h' _ _ rfl
state_before: case h.mp
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
h : IsUniform
α : Type u
a : (P F).A
f : PFunctor.B (P F) a → α
u : α
h' :
  ∀ (a_1 : (P F).A) (f_1 : PFunctor.B (P F) a_1 → α),
    abs { fst := a_1, snd := f_1 } = abs { fst := a, snd := f } → u ∈ f_1 '' univ
⊢ u ∈ f '' univ
Theorem: CauchySeq.bounded_range
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rwa [Nat.cofinite_eq_atTop]
state_before: α : Type u
β : Type v
X : Type ?u.508607
ι : Type ?u.508610
inst✝ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
f : ℕ → α
hf : CauchySeq f
⊢ Cauchy (map f Filter.cofinite)