tasksource/leandojo huggingface dataset:
Theorem: List.get?_eq_some
File: Std/Data/List/Lemmas.lean

tactic: cases get?_len_le hn ▸ e
state_before: α✝ : Type u_1
a : α✝
l : List α✝
n : Nat
e : get? l n = some a
hn : length l ≤ n
⊢ False

tactic: rwa [get?_eq_get this, Option.some.injEq] at e
state_before: α✝ : Type u_1
a : α✝
l : List α✝
n : Nat
e : get? l n = some a
this : n < length l
⊢ get l { val := n, isLt := this } = a
Theorem: Hyperreal.IsSt.map
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rcases ofSeq_surjective x with ⟨g, rfl⟩
state_before: x : ℝ*
r : ℝ
hxr : IsSt x r
f : ℝ → ℝ
hf : ContinuousAt f r
⊢ IsSt (Germ.map f x) (f r)

tactic: exact isSt_ofSeq_iff_tendsto.2 <| hf.tendsto.comp (isSt_ofSeq_iff_tendsto.1 hxr)
state_before: case intro
r : ℝ
f : ℝ → ℝ
hf : ContinuousAt f r
g : ℕ → ℝ
hxr : IsSt (ofSeq g) r
⊢ IsSt (Germ.map f (ofSeq g)) (f r)
Theorem: FractionalIdeal.coe_one
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [coe_one_eq_coeSubmodule_top, coeSubmodule_top]
state_before: R : Type u_2
inst✝² : CommRing R
S : Submonoid R
P : Type u_1
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
⊢ ↑1 = 1
Theorem: not_bddAbove_iff'
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [BddAbove, upperBounds, Set.Nonempty]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ ¬BddAbove s ↔ ∀ (x : α), ∃ y, y ∈ s ∧ ¬y ≤ x
Theorem: continuous_tsum
File: Mathlib/Analysis/Calculus/Series.lean

tactic: simp_rw [continuous_iff_continuousOn_univ] at hf ⊢
state_before: α : Type u_3
β : Type u_1
𝕜 : Type ?u.14249
E : Type ?u.14252
F : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : TopologicalSpace β
f : α → β → F
hf : ∀ (i : α), Continuous (f i)
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
⊢ Continuous fun x => ∑' (n : α), f n x

tactic: exact continuousOn_tsum hf hu fun n x _ => hfu n x
state_before: α : Type u_3
β : Type u_1
𝕜 : Type ?u.14249
E : Type ?u.14252
F : Type u_2
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : TopologicalSpace β
f : α → β → F
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
hf : ∀ (i : α), ContinuousOn (f i) univ
⊢ ContinuousOn (fun x => ∑' (n : α), f n x) univ
Theorem: Finite.injective_iff_surjective_of_equiv
File: Mathlib/Data/Fintype/Card.lean

tactic: simpa [Function.comp] using e.surjective.comp (this.1 (e.symm.injective.comp hinj))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.27313
inst✝ : Finite α
f : α → β
e : α ≃ β
this : Injective (↑e.symm ∘ f) ↔ Surjective (↑e.symm ∘ f)
hinj : Injective f
⊢ Surjective f

tactic: simpa [Function.comp] using e.injective.comp (this.2 (e.symm.surjective.comp hsurj))
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.27313
inst✝ : Finite α
f : α → β
e : α ≃ β
this : Injective (↑e.symm ∘ f) ↔ Surjective (↑e.symm ∘ f)
hsurj : Surjective f
⊢ Injective f
Theorem: MeasureTheory.Measure.toPmf_toMeasure
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: rw [μ.toPmf.toMeasure_apply s hs, ← μ.tsum_indicator_apply_singleton s hs]
state_before: α : Type u_1
β : Type ?u.141584
γ : Type ?u.141587
inst✝³ : Countable α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
s : Set α
hs : MeasurableSet s
⊢ ↑↑(toMeasure (toPmf μ)) s = ↑↑μ s

tactic: rfl
state_before: α : Type u_1
β : Type ?u.141584
γ : Type ?u.141587
inst✝³ : Countable α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
s : Set α
hs : MeasurableSet s
⊢ (∑' (x : α), Set.indicator s (↑(toPmf μ)) x) = ∑' (x : α), Set.indicator s (fun x => ↑↑μ {x}) x
Theorem: Polynomial.Monic.mul_right_ne_zero
File: Mathlib/Data/Polynomial/Monic.lean

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

tactic: rw [Ne.def, ← degree_eq_bot, hp.degree_mul_comm, hp.degree_mul, WithBot.add_eq_bot, not_or,
  degree_eq_bot]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ p * q ≠ 0

tactic: refine' ⟨hq, _⟩
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ ¬q = 0 ∧ ¬degree p = ⊥

tactic: rw [← hp.degree_le_zero_iff_eq_one, not_le] at h
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ ¬degree p = ⊥

tactic: refine' (lt_trans _ h).ne'
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : 0 < degree p
⊢ ¬degree p = ⊥

tactic: simp
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : 0 < degree p
⊢ ⊥ < 0

tactic: simpa [h]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : p = 1
⊢ p * q ≠ 0
Theorem: List.dropSlice_zero₂
File: Std/Data/List/Basic.lean

tactic: simp [dropSlice, dropSlice_zero₂]
state_before: α : Type u_1
n : Nat
x : α
xs : List α
⊢ dropSlice (n + 1) 0 (x :: xs) = x :: xs
Theorem: LinearMap.tailing_disjoint_tunnel_succ
File: Mathlib/LinearAlgebra/Prod.lean

tactic: rw [disjoint_iff]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.543558
M₆ : Type ?u.543561
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ Disjoint (tailing f i n) (↑OrderDual.ofDual (↑(tunnel f i) (n + 1)))

tactic: dsimp [tailing, tunnel, tunnel']
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.543558
M₆ : Type ?u.543561
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ tailing f i n ⊓ ↑OrderDual.ofDual (↑(tunnel f i) (n + 1)) = ⊥

tactic: erw [Submodule.map_inf_eq_map_inf_comap,
  Submodule.comap_map_eq_of_injective (tunnelAux_injective _ i _), inf_comm,
  Submodule.fst_inf_snd, Submodule.map_bot]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.543558
M₆ : Type ?u.543561
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ Submodule.map (tunnelAux f (tunnel' f i n)) (Submodule.snd R M N) ⊓
      Submodule.map (tunnelAux f (tunnel' f i (n + 0))) (Submodule.fst R M N) =
    ⊥
Theorem: IsROrC.ratCast_im
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_ratCast, ofReal_im]
state_before: K : Type u_1
E : Type ?u.6542975
inst✝ : IsROrC K
q : ℚ
⊢ ↑im ↑q = 0
Theorem: Polynomial.map_scaleRoots
File: Mathlib/RingTheory/Polynomial/ScaleRoots.lean

tactic: ext
state_before: A : Type ?u.488366
K : Type ?u.488369
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
x : R
f : R →+* S
h : ↑f (leadingCoeff p) ≠ 0
⊢ map f (scaleRoots p x) = scaleRoots (map f p) (↑f x)

tactic: simp [Polynomial.natDegree_map_of_leadingCoeff_ne_zero _ h]
state_before: case a
A : Type ?u.488366
K : Type ?u.488369
R : Type u_1
S : Type u_2
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Field K
inst✝¹ : CommRing R
inst✝ : CommRing S
M : Submonoid A
p : R[X]
x : R
f : R →+* S
h : ↑f (leadingCoeff p) ≠ 0
n✝ : ℕ
⊢ coeff (map f (scaleRoots p x)) n✝ = coeff (scaleRoots (map f p) (↑f x)) n✝
Theorem: UV.compress_sdiff_sdiff
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

tactic: refine' (compress_of_disjoint_of_le disjoint_sdiff_self_left sdiff_le).trans _
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ a b : α
⊢ compress (a \ b) (b \ a) b = a

tactic: rw [sup_sdiff_self_right, sup_sdiff, disjoint_sdiff_self_right.sdiff_eq_left, sup_eq_right]
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ a b : α
⊢ (b ⊔ a \ b) \ (b \ a) = a

tactic: exact sdiff_sdiff_le
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ a b : α
⊢ b \ (b \ a) ≤ a
Theorem: Irrational.int_add
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_coe_int]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (↑m + x)

tactic: exact h.rat_add m
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (↑↑m + x)
Theorem: Finset.filter_product_left
File: Mathlib/Data/Finset/Prod.lean

tactic: simpa using filter_product p fun _ => true
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.28906
s s' : Finset α
t t' : Finset β
a : α
b : β
p : α → Prop
inst✝ : DecidablePred p
⊢ filter (fun x => p x.fst) (s ×ˢ t) = filter p s ×ˢ t
Theorem: PNat.card_fintype_Ioc
File: Mathlib/Data/PNat/Interval.lean

tactic: rw [← card_Ioc, Fintype.card_ofFinset]
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
Theorem: PNat.XgcdType.reduce_a
File: Mathlib/Data/PNat/Xgcd.lean

tactic: rw [reduce]
state_before: u✝ u : XgcdType
h : r u = 0
⊢ reduce u = finish u

tactic: exact if_pos h
state_before: u✝ u : XgcdType
h : r u = 0
⊢ (if x : r u = 0 then finish u else flip (reduce (step u))) = finish u
Theorem: Nat.ArithmeticFunction.cardDistinctFactors_eq_cardFactors_iff_squarefree
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [squarefree_iff_nodup_factors h0, cardDistinctFactors_apply]
state_before: R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
⊢ ↑ω n = ↑Ω n ↔ Squarefree n

tactic: constructor <;> intro h
state_before: R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
⊢ List.length (List.dedup (factors n)) = ↑Ω n ↔ List.Nodup (factors n)

tactic: rw [← n.factors.dedup_sublist.eq_of_length h]
state_before: case mp
R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
h : List.length (List.dedup (factors n)) = ↑Ω n
⊢ List.Nodup (factors n)

tactic: apply List.nodup_dedup
state_before: case mp
R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
h : List.length (List.dedup (factors n)) = ↑Ω n
⊢ List.Nodup (List.dedup (factors n))

tactic: rw [h.dedup]
state_before: case mpr
R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
h : List.Nodup (factors n)
⊢ List.length (List.dedup (factors n)) = ↑Ω n

tactic: rfl
state_before: case mpr
R : Type ?u.569435
n : ℕ
h0 : n ≠ 0
h : List.Nodup (factors n)
⊢ List.length (factors n) = ↑Ω n
Theorem: Finset.min'_lt_max'_of_card
File: Mathlib/Data/Finset/Lattice.lean

tactic: rcases one_lt_card.1 h₂ with ⟨a, ha, b, hb, hab⟩
state_before: F : Type ?u.344901
α : Type u_1
β : Type ?u.344907
γ : Type ?u.344910
ι : Type ?u.344913
κ : Type ?u.344916
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
h₂ : 1 < card s
⊢ min' s (_ : Finset.Nonempty s) < max' s (_ : Finset.Nonempty s)

tactic: exact s.min'_lt_max' ha hb hab
state_before: case intro.intro.intro.intro
F : Type ?u.344901
α : Type u_1
β : Type ?u.344907
γ : Type ?u.344910
ι : Type ?u.344913
κ : Type ?u.344916
inst✝ : LinearOrder α
s : Finset α
H : Finset.Nonempty s
x : α
h₂ : 1 < card s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≠ b
⊢ min' s (_ : Finset.Nonempty s) < max' s (_ : Finset.Nonempty s)
Theorem: Filter.coprodᵢ_cofinite
File: Mathlib/Order/Filter/Cofinite.lean

tactic: simp only [compl_mem_coprodᵢ, mem_cofinite, compl_compl, forall_finite_image_eval_iff]
state_before: ι : Type u_2
α✝ : Type ?u.3999
β : Type ?u.4002
l : Filter α✝
α : ι → Type u_1
inst✝ : Finite ι
s : Set ((i : ι) → α i)
⊢ (sᶜ ∈ Filter.coprodᵢ fun i => cofinite) ↔ sᶜ ∈ cofinite
Theorem: Int.pairwise_one_le_dist
File: Mathlib/Topology/Instances/Int.lean

tactic: intro m n hne
state_before: ⊢ Pairwise fun m n => 1 ≤ dist m n

tactic: rw [dist_eq]
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ dist m n

tactic: norm_cast
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ abs (↑m - ↑n)

tactic: rwa [← zero_add (1 : ℤ), Int.add_one_le_iff, abs_pos, sub_ne_zero]
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ abs (m - n)
Theorem: Matrix.charpoly_reindex
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean

tactic: unfold Matrix.charpoly
state_before: R : Type u
inst✝⁴ : CommRing R
n : Type w
inst✝³ : DecidableEq n
inst✝² : Fintype n
m : Type v
inst✝¹ : DecidableEq m
inst✝ : Fintype m
e : n ≃ m
M : Matrix n n R
⊢ charpoly (↑(reindex e e) M) = charpoly M

tactic: rw [charmatrix_reindex, Matrix.det_reindex_self]
state_before: R : Type u
inst✝⁴ : CommRing R
n : Type w
inst✝³ : DecidableEq n
inst✝² : Fintype n
m : Type v
inst✝¹ : DecidableEq m
inst✝ : Fintype m
e : n ≃ m
M : Matrix n n R
⊢ det (charmatrix (↑(reindex e e) M)) = det (charmatrix M)
Theorem: Multiset.prod_eq_pow_single
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: induction' s using Quotient.inductionOn with l
state_before: ι : Type ?u.29694
α : Type u_1
β : Type ?u.29700
γ : Type ?u.29703
inst✝¹ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
a : α
h : ∀ (a' : α), a' ≠ a → a' ∈ s → a' = 1
⊢ prod s = a ^ count a s

tactic: simp [List.prod_eq_pow_single a h]
state_before: case h
ι : Type ?u.29694
α : Type u_1
β : Type ?u.29700
γ : Type ?u.29703
inst✝¹ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq α
a : α
h✝ : ∀ (a' : α), a' ≠ a → a' ∈ s → a' = 1
l : List α
h : ∀ (a' : α), a' ≠ a → a' ∈ Quotient.mk (List.isSetoid α) l → a' = 1
⊢ prod (Quotient.mk (List.isSetoid α) l) = a ^ count a (Quotient.mk (List.isSetoid α) l)
Theorem: Set.inclusion_inclusion
File: Mathlib/Data/Set/Basic.lean

tactic: cases x
state_before: α : Type u_1
s t u : Set α
hst : s ⊆ t
htu : t ⊆ u
x : ↑s
⊢ inclusion htu (inclusion hst x) = inclusion (_ : s ⊆ u) x

tactic: rfl
state_before: case mk
α : Type u_1
s t u : Set α
hst : s ⊆ t
htu : t ⊆ u
val✝ : α
property✝ : val✝ ∈ s
⊢ inclusion htu (inclusion hst { val := val✝, property := property✝ }) =
    inclusion (_ : s ⊆ u) { val := val✝, property := property✝ }
Theorem: Cardinal.lift_mk_shrink''
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_umax', lift_mk_shrink.{max u v, v, 0} α, ← lift_umax, lift_id]
state_before: α✝ β : Type u
α : Type (max u v)
inst✝ : Small α
⊢ lift (#Shrink α) = (#α)
Theorem: MeasureTheory.FiniteMeasure.restrict_nonzero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [← mass_nonzero_iff, restrict_mass]
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type ?u.41322
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ restrict μ A ≠ 0 ↔ (fun s => ENNReal.toNNReal (↑↑↑μ s)) A ≠ 0
Theorem: Fin.succ_cast_eq
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [h]
state_before: n m n' : ℕ
i : Fin n
h : n = n'
⊢ Nat.succ n = Nat.succ n'

tactic: simp
state_before: n m n' : ℕ
i : Fin n
h : n = n'
⊢ ↑(succ (↑(cast h) i)) = ↑(↑(cast (_ : Nat.succ n = Nat.succ n')) (succ i))
Theorem: TopCat.piIsoPi_inv_π
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: simp [piIsoPi]
state_before: J : Type v
inst✝ : SmallCategory J
ι : Type v
α : ι → TopCatMax
i : ι
⊢ (piIsoPi α).inv ≫ Pi.π α i = piπ α i
Theorem: Basis.ofVectorSpaceIndex.linearIndependent
File: Mathlib/LinearAlgebra/Basis.lean

tactic: convert (ofVectorSpace K V).linearIndependent
state_before: ι : Type ?u.1148087
ι' : Type ?u.1148090
R : Type ?u.1148093
R₂ : Type ?u.1148096
K : Type u_1
M : Type ?u.1148102
M' : Type ?u.1148105
M'' : Type ?u.1148108
V : Type u
V' : Type ?u.1148113
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
⊢ LinearIndependent K Subtype.val

tactic: ext x
state_before: case h.e'_4
ι : Type ?u.1148087
ι' : Type ?u.1148090
R : Type ?u.1148093
R₂ : Type ?u.1148096
K : Type u_1
M : Type ?u.1148102
M' : Type ?u.1148105
M'' : Type ?u.1148108
V : Type u
V' : Type ?u.1148113
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
⊢ Subtype.val = ↑(ofVectorSpace K V)

tactic: rw [ofVectorSpace_apply_self]
state_before: case h.e'_4.h
ι : Type ?u.1148087
ι' : Type ?u.1148090
R : Type ?u.1148093
R₂ : Type ?u.1148096
K : Type u_1
M : Type ?u.1148102
M' : Type ?u.1148105
M'' : Type ?u.1148108
V : Type u
V' : Type ?u.1148113
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y z : V
x : { x // x ∈ ofVectorSpaceIndex K V }
⊢ ↑x = ↑(ofVectorSpace K V) x
Theorem: Finset.prod_comm'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: classical
  have : ∀ z : γ × α, (z ∈ s.biUnion fun x => (t x).map <| Function.Embedding.sectr x _) ↔
    z.1 ∈ s ∧ z.2 ∈ t z.1 := by
    rintro ⟨x, y⟩
    simp only [mem_biUnion, mem_map, Function.Embedding.sectr_apply, Prod.mk.injEq,
      exists_eq_right, ← and_assoc]
  exact
    (prod_finset_product' _ _ _ this).symm.trans
      ((prod_finset_product_right' _ _ _) fun ⟨x, y⟩ => (this _).trans ((h x y).trans and_comm))
state_before: ι : Type ?u.324815
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset γ
t : γ → Finset α
t' : Finset α
s' : α → Finset γ
h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t'
f : γ → α → β
⊢ ∏ x in s, ∏ y in t x, f x y = ∏ y in t', ∏ x in s' y, f x y

tactic: have : ∀ z : γ × α, (z ∈ s.biUnion fun x => (t x).map <| Function.Embedding.sectr x _) ↔
  z.1 ∈ s ∧ z.2 ∈ t z.1 := by
  rintro ⟨x, y⟩
  simp only [mem_biUnion, mem_map, Function.Embedding.sectr_apply, Prod.mk.injEq,
    exists_eq_right, ← and_assoc]
state_before: ι : Type ?u.324815
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset γ
t : γ → Finset α
t' : Finset α
s' : α → Finset γ
h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t'
f : γ → α → β
⊢ ∏ x in s, ∏ y in t x, f x y = ∏ y in t', ∏ x in s' y, f x y

tactic: exact
  (prod_finset_product' _ _ _ this).symm.trans
    ((prod_finset_product_right' _ _ _) fun ⟨x, y⟩ => (this _).trans ((h x y).trans and_comm))
state_before: ι : Type ?u.324815
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset γ
t : γ → Finset α
t' : Finset α
s' : α → Finset γ
h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t'
f : γ → α → β
this :
  ∀ (z : γ × α), (z ∈ Finset.biUnion s fun x => map (Function.Embedding.sectr x α) (t x)) ↔ z.fst ∈ s ∧ z.snd ∈ t z.fst
⊢ ∏ x in s, ∏ y in t x, f x y = ∏ y in t', ∏ x in s' y, f x y

tactic: rintro ⟨x, y⟩
state_before: ι : Type ?u.324815
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset γ
t : γ → Finset α
t' : Finset α
s' : α → Finset γ
h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t'
f : γ → α → β
⊢ ∀ (z : γ × α), (z ∈ Finset.biUnion s fun x => map (Function.Embedding.sectr x α) (t x)) ↔ z.fst ∈ s ∧ z.snd ∈ t z.fst

tactic: simp only [mem_biUnion, mem_map, Function.Embedding.sectr_apply, Prod.mk.injEq,
  exists_eq_right, ← and_assoc]
state_before: case mk
ι : Type ?u.324815
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset γ
t : γ → Finset α
t' : Finset α
s' : α → Finset γ
h : ∀ (x : γ) (y : α), x ∈ s ∧ y ∈ t x ↔ x ∈ s' y ∧ y ∈ t'
f : γ → α → β
x : γ
y : α
⊢ ((x, y) ∈ Finset.biUnion s fun x => map (Function.Embedding.sectr x α) (t x)) ↔
    (x, y).fst ∈ s ∧ (x, y).snd ∈ t (x, y).fst
Theorem: Mathlib.Tactic.Ring.pow_bit0
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
b c : R
x✝¹ : a ^ k = b
x✝ : b * b = c
⊢ a ^ Nat.mul 2 k = c

tactic: simp [Nat.succ_mul, pow_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
k : ℕ
⊢ a ^ Nat.mul 2 k = a ^ k * a ^ k
Theorem: Set.einfsep_insert
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: refine' le_antisymm (le_min einfsep_insert_le (einfsep_anti (subset_insert _ _))) _
state_before: α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
x y z : α
s t : Set α
⊢ einfsep (insert x s) = (⨅ (y : α) (_ : y ∈ s) (_ : x ≠ y), edist x y) ⊓ einfsep s

tactic: simp_rw [le_einfsep_iff, inf_le_iff, mem_insert_iff]
state_before: α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
x y z : α
s t : Set α
⊢ (⨅ (y : α) (_ : y ∈ s) (_ : x ≠ y), edist x y) ⊓ einfsep s ≤ einfsep (insert x s)

tactic: rintro y (rfl | hy) z (rfl | hz) hyz
state_before: α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
x y z : α
s t : Set α
⊢ ∀ (x_1 : α),
    x_1 = x ∨ x_1 ∈ s →
      ∀ (y : α),
        y = x ∨ y ∈ s → x_1 ≠ y → (⨅ (y : α) (_ : y ∈ s) (_ : x ≠ y), edist x y) ≤ edist x_1 y ∨ einfsep s ≤ edist x_1 y

tactic: exact False.elim (hyz rfl)
state_before: case inl.inl
α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
y z✝ : α
s t : Set α
z : α
hyz : z ≠ z
⊢ (⨅ (y : α) (_ : y ∈ s) (_ : z ≠ y), edist z y) ≤ edist z z ∨ einfsep s ≤ edist z z

tactic: exact Or.inl (iInf_le_of_le _ (iInf₂_le hz hyz))
state_before: case inl.inr
α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
y✝ z✝ : α
s t : Set α
y z : α
hz : z ∈ s
hyz : y ≠ z
⊢ (⨅ (y_1 : α) (_ : y_1 ∈ s) (_ : y ≠ y_1), edist y y_1) ≤ edist y z ∨ einfsep s ≤ edist y z

tactic: rw [edist_comm]
state_before: case inr.inl
α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
y✝ z✝ : α
s t : Set α
y : α
hy : y ∈ s
z : α
hyz : y ≠ z
⊢ (⨅ (y : α) (_ : y ∈ s) (_ : z ≠ y), edist z y) ≤ edist y z ∨ einfsep s ≤ edist y z

tactic: exact Or.inl (iInf_le_of_le _ (iInf₂_le hy hyz.symm))
state_before: case inr.inl
α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
y✝ z✝ : α
s t : Set α
y : α
hy : y ∈ s
z : α
hyz : y ≠ z
⊢ (⨅ (y : α) (_ : y ∈ s) (_ : z ≠ y), edist z y) ≤ edist z y ∨ einfsep s ≤ edist z y

tactic: exact Or.inr (einfsep_le_edist_of_mem hy hz hyz)
state_before: case inr.inr
α : Type u_1
β : Type ?u.44124
inst✝ : PseudoEMetricSpace α
x y✝ z✝ : α
s t : Set α
y : α
hy : y ∈ s
z : α
hz : z ∈ s
hyz : y ≠ z
⊢ (⨅ (y : α) (_ : y ∈ s) (_ : x ≠ y), edist x y) ≤ edist y z ∨ einfsep s ≤ edist y z
Theorem: HasStrictDerivAt.complexToReal_fderiv
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [Complex.restrictScalars_one_smulRight] using h.hasStrictFDerivAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type ?u.117471
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h : HasStrictDerivAt f f' x
⊢ HasStrictFDerivAt f (f' • 1) x