tasksource/leandojo huggingface dataset:
Theorem: Ordnode.Sized.rotateR_size
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← size_dual, dual_rotateR, hl.dual.rotateL_size, size_dual, size_dual, add_comm (size l)]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
⊢ size (Ordnode.rotateR l x r) = size l + size r + 1
Theorem: Fin.Iio_castSucc
File: Mathlib/Data/Fintype/Fin.lean

tactic: apply Finset.map_injective Fin.valEmbedding
state_before: α : Type ?u.8321
β : Type ?u.8324
n : ℕ
i : Fin n
⊢ Iio (↑castSucc i) = map castSucc.toEmbedding (Iio i)

tactic: rw [Finset.map_map, Fin.map_valEmbedding_Iio]
state_before: case a
α : Type ?u.8321
β : Type ?u.8324
n : ℕ
i : Fin n
⊢ map valEmbedding (Iio (↑castSucc i)) = map valEmbedding (map castSucc.toEmbedding (Iio i))

tactic: exact (Fin.map_valEmbedding_Iio i).symm
state_before: case a
α : Type ?u.8321
β : Type ?u.8324
n : ℕ
i : Fin n
⊢ Iio ↑(↑castSucc i) = map (Function.Embedding.trans castSucc.toEmbedding valEmbedding) (Iio i)
Theorem: Filter.HasBasis.prod_self
File: Mathlib/Order/Filter/Bases.lean

tactic: simpa only [exists_prop, subset_inter_iff] using
  hl.mem_iff.1 (inter_mem (hl.mem_of_mem hi) (hl.mem_of_mem hj))
state_before: α : Type u_1
β : Type ?u.81162
γ : Type ?u.81165
ι : Sort u_2
ι' : Sort ?u.81171
la : Filter α
pa : ι → Prop
sa : ι → Set α
lb : Filter β
pb : ι' → Prop
sb : ι' → Set β
f : α → β
hl : HasBasis la pa sa
i j : ι
hi : pa i
hj : pa j
⊢ ∃ k, pa k ∧ sa k ⊆ sa i ∧ sa k ⊆ sa j
Theorem: Matrix.mulVec_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.885794
m : Type u_3
n : Type u_1
o : Type u_2
m' : o → Type ?u.885808
n' : o → Type ?u.885813
R : Type ?u.885816
S : Type ?u.885819
α : Type v
β : Type w
γ : Type ?u.885826
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype o
v : o → α
M : Matrix m n α
N : Matrix n o α
⊢ mulVec M (mulVec N v) = mulVec (M ⬝ N) v

tactic: symm
state_before: case h
l : Type ?u.885794
m : Type u_3
n : Type u_1
o : Type u_2
m' : o → Type ?u.885808
n' : o → Type ?u.885813
R : Type ?u.885816
S : Type ?u.885819
α : Type v
β : Type w
γ : Type ?u.885826
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype o
v : o → α
M : Matrix m n α
N : Matrix n o α
x✝ : m
⊢ mulVec M (mulVec N v) x✝ = mulVec (M ⬝ N) v x✝

tactic: apply dotProduct_assoc
state_before: case h
l : Type ?u.885794
m : Type u_3
n : Type u_1
o : Type u_2
m' : o → Type ?u.885808
n' : o → Type ?u.885813
R : Type ?u.885816
S : Type ?u.885819
α : Type v
β : Type w
γ : Type ?u.885826
inst✝² : NonUnitalSemiring α
inst✝¹ : Fintype n
inst✝ : Fintype o
v : o → α
M : Matrix m n α
N : Matrix n o α
x✝ : m
⊢ mulVec (M ⬝ N) v x✝ = mulVec M (mulVec N v) x✝
Theorem: Basis.toLin_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: rw [toLin_self, id_apply, e.sum_toMatrix_smul_self]
state_before: ι : Type u_1
ι' : Type u_2
κ : Type ?u.289930
κ' : Type ?u.289933
R : Type u_3
M : Type u_4
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type ?u.290126
M₂ : Type ?u.290129
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i✝ : ι
j : ι'
inst✝² : Fintype ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
v : Basis ι' R M
i : ι'
⊢ ↑(↑(toLin v e) (toMatrix e ↑v)) (↑v i) = ↑LinearMap.id (↑v i)
Theorem: Complex.continuous_normSq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa [← normSq_eq_abs] using continuous_abs.pow 2
state_before: E : Type ?u.191731
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ Continuous ↑normSq
Theorem: Nat.exists_subseq_of_forall_mem_union
File: Mathlib/Order/OrderIsoNat.lean

tactic: classical
  have : Infinite (e ⁻¹' s) ∨ Infinite (e ⁻¹' t) := by
    simp only [Set.infinite_coe_iff, ← Set.infinite_union, ← Set.preimage_union,
      Set.eq_univ_of_forall fun n => Set.mem_preimage.2 (he n), Set.infinite_univ]
  cases this
  exacts [⟨Nat.orderEmbeddingOfSet (e ⁻¹' s), Or.inl fun n => (Nat.Subtype.ofNat (e ⁻¹' s) _).2⟩,
    ⟨Nat.orderEmbeddingOfSet (e ⁻¹' t), Or.inr fun n => (Nat.Subtype.ofNat (e ⁻¹' t) _).2⟩]
state_before: α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
⊢ ∃ g, (∀ (n : ℕ), e (↑g n) ∈ s) ∨ ∀ (n : ℕ), e (↑g n) ∈ t

tactic: have : Infinite (e ⁻¹' s) ∨ Infinite (e ⁻¹' t) := by
  simp only [Set.infinite_coe_iff, ← Set.infinite_union, ← Set.preimage_union,
    Set.eq_univ_of_forall fun n => Set.mem_preimage.2 (he n), Set.infinite_univ]
state_before: α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
⊢ ∃ g, (∀ (n : ℕ), e (↑g n) ∈ s) ∨ ∀ (n : ℕ), e (↑g n) ∈ t

tactic: cases this
state_before: α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
this : Infinite ↑(e ⁻¹' s) ∨ Infinite ↑(e ⁻¹' t)
⊢ ∃ g, (∀ (n : ℕ), e (↑g n) ∈ s) ∨ ∀ (n : ℕ), e (↑g n) ∈ t

tactic: exacts [⟨Nat.orderEmbeddingOfSet (e ⁻¹' s), Or.inl fun n => (Nat.Subtype.ofNat (e ⁻¹' s) _).2⟩,
  ⟨Nat.orderEmbeddingOfSet (e ⁻¹' t), Or.inr fun n => (Nat.Subtype.ofNat (e ⁻¹' t) _).2⟩]
state_before: case inl
α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
h✝ : Infinite ↑(e ⁻¹' s)
⊢ ∃ g, (∀ (n : ℕ), e (↑g n) ∈ s) ∨ ∀ (n : ℕ), e (↑g n) ∈ t

case inr
α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
h✝ : Infinite ↑(e ⁻¹' t)
⊢ ∃ g, (∀ (n : ℕ), e (↑g n) ∈ s) ∨ ∀ (n : ℕ), e (↑g n) ∈ t

tactic: simp only [Set.infinite_coe_iff, ← Set.infinite_union, ← Set.preimage_union,
  Set.eq_univ_of_forall fun n => Set.mem_preimage.2 (he n), Set.infinite_univ]
state_before: α : Type u_1
s✝ : Set ℕ
inst✝ : Infinite ↑s✝
s t : Set α
e : ℕ → α
he : ∀ (n : ℕ), e n ∈ s ∪ t
⊢ Infinite ↑(e ⁻¹' s) ∨ Infinite ↑(e ⁻¹' t)
Theorem: MeasureTheory.SimpleFunc.norm_integral_le_integral_norm
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: refine' (norm_setToSimpleFunc_le_integral_norm _ (fun s _ _ => _) hf).trans (one_mul _).le
state_before: α : Type u_1
E : Type u_2
F : Type ?u.205081
𝕜 : Type ?u.205084
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.205186
F' : Type ?u.205189
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α →ₛ E
hf : Integrable ↑f
⊢ ‖integral μ f‖ ≤ integral μ (map norm f)

tactic: exact (norm_weightedSMul_le s).trans (one_mul _).symm.le
state_before: α : Type u_1
E : Type u_2
F : Type ?u.205081
𝕜 : Type ?u.205084
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.205186
F' : Type ?u.205189
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
f : α →ₛ E
hf : Integrable ↑f
s : Set α
x✝¹ : MeasurableSet s
x✝ : ↑↑μ s < ⊤
⊢ ‖weightedSMul μ s‖ ≤ 1 * ENNReal.toReal (↑↑μ s)
Theorem: Fermat42.exists_odd_minimal
File: Mathlib/NumberTheory/Fermat4.lean

tactic: obtain ⟨a0, b0, c0, hf⟩ := exists_minimal h
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1

tactic: cases' Int.emod_two_eq_zero_or_one a0 with hap hap
state_before: case intro.intro.intro
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1

tactic: exact ⟨a0, ⟨b0, ⟨c0, hf, hap⟩⟩⟩
state_before: case intro.intro.intro.inr
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1

tactic: cases' Int.emod_two_eq_zero_or_one b0 with hbp hbp
state_before: case intro.intro.intro.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1

tactic: exfalso
state_before: case intro.intro.intro.inl.inl
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 0
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1

tactic: have h1 : 2 ∣ (Int.gcd a0 b0 : ℤ) :=
  Int.dvd_gcd (Int.dvd_of_emod_eq_zero hap) (Int.dvd_of_emod_eq_zero hbp)
state_before: case intro.intro.intro.inl.inl.h
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 0
⊢ False

tactic: rw [Int.gcd_eq_one_iff_coprime.mpr (coprime_of_minimal hf)] at h1
state_before: case intro.intro.intro.inl.inl.h
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 0
h1 : 2 ∣ ↑(Int.gcd a0 b0)
⊢ False

tactic: revert h1
state_before: case intro.intro.intro.inl.inl.h
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 0
h1 : 2 ∣ ↑1
⊢ False

tactic: norm_num
state_before: case intro.intro.intro.inl.inl.h
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 0
⊢ 2 ∣ ↑1 → False

tactic: exact ⟨b0, ⟨a0, ⟨c0, minimal_comm hf, hbp⟩⟩⟩
state_before: case intro.intro.intro.inl.inr
a b c : ℤ
h : Fermat42 a b c
a0 b0 c0 : ℤ
hf : Minimal a0 b0 c0
hap : a0 % 2 = 0
hbp : b0 % 2 = 1
⊢ ∃ a0 b0 c0, Minimal a0 b0 c0 ∧ a0 % 2 = 1
Theorem: IsRingHom.id
File: Mathlib/Deprecated/Ring.lean

tactic: refine' { .. } <;> intros <;> rfl
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf : IsRingHom f
x y : α
⊢ IsRingHom _root_.id
Theorem: LowerSet.mem_sSup_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [exists_prop, SetLike.mem_coe]
state_before: α : Type u_1
β : Type ?u.75951
γ : Type ?u.75954
ι : Sort ?u.75957
κ : ι → Sort ?u.75962
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
⊢ (∃ i j, a ∈ ↑i) ↔ ∃ s, s ∈ S ∧ a ∈ s
Theorem: Nat.bit1_eq_one
File: Mathlib/Data/Nat/Bits.lean

tactic: subst h
state_before: n✝ n : ℕ
h : n = 0
⊢ bit1 n = 1

tactic: rfl
state_before: n : ℕ
⊢ bit1 0 = 1
Theorem: convexHull_add
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simp_rw [← image2_add, ← image_prod, IsLinearMap.isLinearMap_add.convexHull_image,
  convexHull_prod]
state_before: R : Type u_2
E : Type u_1
F : Type ?u.407254
ι : Type ?u.407257
ι' : Type ?u.407260
α : Type ?u.407263
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t✝ : Finset ι
w : ι → R
z : ι → E
s t : Set E
⊢ ↑(convexHull R).toOrderHom (s + t) = ↑(convexHull R).toOrderHom s + ↑(convexHull R).toOrderHom t
Theorem: Vector.traverse_eq_map_id
File: Mathlib/Data/Vector/Basic.lean

tactic: rintro ⟨x, rfl⟩
state_before: n : ℕ
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
⊢ ∀ (x : Vector α n), Vector.traverse (pure ∘ f) x = pure (map f x)

tactic: simp!
state_before: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverse (pure ∘ f) { val := x, property := (_ : List.length x = List.length x) } =
    pure (map f { val := x, property := (_ : List.length x = List.length x) })

tactic: induction x <;> simp! [*, functor_norm] <;> rfl
state_before: case mk
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverseAux (pure ∘ f) x =
    { val := List.map f x, property := (_ : List.length (List.map f x) = List.length x) }
Theorem: List.mem_rtakeWhile_imp
File: Mathlib/Data/List/Rdrop.lean

tactic: rw [rtakeWhile, mem_reverse] at hx
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
hx : x ∈ rtakeWhile p l
⊢ p x = true

tactic: exact mem_takeWhile_imp hx
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
hx : x ∈ takeWhile p (reverse l)
⊢ p x = true
Theorem: Set.mk_preimage_sigma_fn_eq_if
File: Mathlib/Data/Set/Sigma.lean

tactic: split_ifs <;> simp [*]
state_before: ι : Type u_2
ι' : Type ?u.13241
α : ι → Type u_3
β✝ : ι → Type ?u.13251
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β : Type u_1
inst✝ : DecidablePred fun x => x ∈ s
g : β → α i
x✝ : β
⊢ x✝ ∈ (fun b => { fst := i, snd := g b }) ⁻¹' Set.Sigma s t ↔ x✝ ∈ if i ∈ s then g ⁻¹' t i else ∅
Theorem: MeasureTheory.OuterMeasure.ext_nonempty
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [he, empty', empty']
state_before: α : Type u_1
β : Type ?u.23881
R : Type ?u.23884
R' : Type ?u.23887
ms : Set (OuterMeasure α)
m μ₁ μ₂ : OuterMeasure α
h : ∀ (s : Set α), Set.Nonempty s → ↑μ₁ s = ↑μ₂ s
s : Set α
he : s = ∅
⊢ ↑μ₁ s = ↑μ₂ s
Theorem: MeasureTheory.OuterMeasure.comap_iSup
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [comap_apply, iSup_apply]
state_before: α : Type u_3
β✝ : Type ?u.94749
R : Type ?u.94752
R' : Type ?u.94755
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
β : Type u_1
ι : Sort u_2
f : α → β
m : ι → OuterMeasure β
s : Set α
⊢ ↑(↑(comap f) (⨆ (i : ι), m i)) s = ↑(⨆ (i : ι), ↑(comap f) (m i)) s
Theorem: MatrixEquivTensor.left_inv
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: induction' M using TensorProduct.induction_on with a m x y hx hy
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : A ⊗[R] Matrix n n R
⊢ invFun R A n (↑(toFunAlgHom R A n) M) = M

tactic: simp
state_before: case C0
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
⊢ invFun R A n (↑(toFunAlgHom R A n) 0) = 0

tactic: simp
state_before: case C1
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
a : A
m : Matrix n n R
⊢ invFun R A n (↑(toFunAlgHom R A n) (a ⊗ₜ[R] m)) = a ⊗ₜ[R] m

tactic: rw [map_add]
state_before: case Cp
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
x y : A ⊗[R] Matrix n n R
hx : invFun R A n (↑(toFunAlgHom R A n) x) = x
hy : invFun R A n (↑(toFunAlgHom R A n) y) = y
⊢ invFun R A n (↑(toFunAlgHom R A n) (x + y)) = x + y

tactic: conv_rhs => rw [← hx, ← hy, ← invFun_add]
state_before: case Cp
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
x y : A ⊗[R] Matrix n n R
hx : invFun R A n (↑(toFunAlgHom R A n) x) = x
hy : invFun R A n (↑(toFunAlgHom R A n) y) = y
⊢ invFun R A n (↑(toFunAlgHom R A n) x + ↑(toFunAlgHom R A n) y) = x + y
Theorem: Asymptotics.IsBigOWith.smul
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: intros
state_before: case refine'_2
α : Type u_1
β : Type ?u.560740
E : Type ?u.560743
F : Type ?u.560746
G : Type ?u.560749
E' : Type u_4
F' : Type u_5
G' : Type ?u.560758
E'' : Type ?u.560761
F'' : Type ?u.560764
G'' : Type ?u.560767
R : Type ?u.560770
R' : Type ?u.560773
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : NormedSpace 𝕜' F'
k₁ : α → 𝕜
k₂ : α → 𝕜'
h₁ : IsBigOWith c l k₁ k₂
h₂ : IsBigOWith c' l f' g'
⊢ ∀ (x : α), ‖k₂ x‖ * ‖g' x‖ = ‖k₂ x • g' x‖

tactic: simp only [norm_smul]
state_before: case refine'_2
α : Type u_1
β : Type ?u.560740
E : Type ?u.560743
F : Type ?u.560746
G : Type ?u.560749
E' : Type u_4
F' : Type u_5
G' : Type ?u.560758
E'' : Type ?u.560761
F'' : Type ?u.560764
G'' : Type ?u.560767
R : Type ?u.560770
R' : Type ?u.560773
𝕜 : Type u_2
𝕜' : Type u_3
inst✝¹⁴ : Norm E
inst✝¹³ : Norm F
inst✝¹² : Norm G
inst✝¹¹ : SeminormedAddCommGroup E'
inst✝¹⁰ : SeminormedAddCommGroup F'
inst✝⁹ : SeminormedAddCommGroup G'
inst✝⁸ : NormedAddCommGroup E''
inst✝⁷ : NormedAddCommGroup F''
inst✝⁶ : NormedAddCommGroup G''
inst✝⁵ : SeminormedRing R
inst✝⁴ : SeminormedRing R'
inst✝³ : NormedField 𝕜
inst✝² : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : NormedSpace 𝕜' F'
k₁ : α → 𝕜
k₂ : α → 𝕜'
h₁ : IsBigOWith c l k₁ k₂
h₂ : IsBigOWith c' l f' g'
x✝ : α
⊢ ‖k₂ x✝‖ * ‖g' x✝‖ = ‖k₂ x✝ • g' x✝‖
Theorem: norm_one'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [← dist_one_right, dist_self]
state_before: 𝓕 : Type ?u.72975
𝕜 : Type ?u.72978
α : Type ?u.72981
ι : Type ?u.72984
κ : Type ?u.72987
E : Type u_1
F : Type ?u.72993
G : Type ?u.72996
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ ‖1‖ = 0
Theorem: ContinuousOrderHom.cancel_left
File: Mathlib/Topology/Order/Hom/Basic.lean

tactic: rw [← comp_apply, h, comp_apply]
state_before: F : Type ?u.20465
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.20477
inst✝⁷ : TopologicalSpace α
inst✝⁶ : Preorder α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : Preorder β
inst✝³ : TopologicalSpace γ
inst✝² : Preorder γ
inst✝¹ : TopologicalSpace δ
inst✝ : Preorder δ
g : β →Co γ
f₁ f₂ : α →Co β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: Pmf.filter_apply_ne_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: rw [Ne.def, filter_apply_eq_zero_iff, not_or, Classical.not_not, Classical.not_not]
state_before: α : Type u_1
β : Type ?u.164201
γ : Type ?u.164204
p : Pmf α
s : Set α
h : ∃ a, a ∈ s ∧ a ∈ support p
a : α
⊢ ↑(filter p s h) a ≠ 0 ↔ a ∈ s ∧ a ∈ support p
Theorem: toIocMod_eq_sub_fract_mul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod, toIocDiv_eq_neg_floor, Int.fract]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ toIocMod hp a b = a + p - Int.fract ((a + p - b) / p) * p

tactic: field_simp [hp.ne.symm]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b - -⌊(a + p - b) / p⌋ • p = a + p - ((a + p - b) / p - ↑⌊(a + p - b) / p⌋) * p

tactic: ring
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
a b : α
⊢ b + ↑⌊(a + p - b) / p⌋ * p = a + p - (a + p - b - p * ↑⌊(a + p - b) / p⌋)
Theorem: AlgebraicGeometry.StructureSheaf.localizationToStalk_mk'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: erw [← germ_toOpen R (PrimeSpectrum.basicOpen s) ⟨x, s.2⟩,
  ← germ_toOpen R (PrimeSpectrum.basicOpen s) ⟨x, s.2⟩, ← RingHom.map_mul, toOpen_eq_const,
  toOpen_eq_const, const_mul_cancel']
state_before: R : Type u
inst✝ : CommRing R
x : ↑(PrimeSpectrum.Top R)
f : R
s : { x_1 // x_1 ∈ Ideal.primeCompl x.asIdeal }
⊢ ↑(toStalk R x) f =
    ↑(toStalk R x) ↑s *
      ↑(germ (Sheaf.presheaf (structureSheaf R)) { val := x, property := (_ : ↑s ∈ Ideal.primeCompl x.asIdeal) })
        (const R f (↑s) (PrimeSpectrum.basicOpen ↑s)
          (_ : ∀ (x_1 : ↑(PrimeSpectrum.Top R)), x_1 ∈ PrimeSpectrum.basicOpen ↑s → x_1 ∈ PrimeSpectrum.basicOpen ↑s))
Theorem: Projectivization.Subspace.span_univ
File: Mathlib/LinearAlgebra/ProjectiveSpace/Subspace.lean

tactic: rw [eq_top_iff, SetLike.le_def]
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ span Set.univ = ⊤

tactic: intro x _hx
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ∀ ⦃x : ℙ K V⦄, x ∈ ⊤ → x ∈ span Set.univ

tactic: exact subset_span _ (Set.mem_univ x)
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
x : ℙ K V
_hx : x ∈ ⊤
⊢ x ∈ span Set.univ
Theorem: Matrix.blockDiag'_diagonal
File: Mathlib/Data/Matrix/Block.lean

tactic: obtain rfl | hij := Decidable.eq_or_ne i j
state_before: l : Type ?u.250274
m : Type ?u.250277
n : Type ?u.250280
o : Type u_1
p : Type ?u.250286
q : Type ?u.250289
m' : o → Type u_2
n' : o → Type ?u.250299
p' : o → Type ?u.250304
R : Type ?u.250307
S : Type ?u.250310
α : Type u_3
β : Type ?u.250316
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : (i : o) → DecidableEq (m' i)
d : (i : o) × m' i → α
k : o
i j : m' k
⊢ blockDiag' (diagonal d) k i j = diagonal (fun i => d { fst := k, snd := i }) i j

tactic: rw [blockDiag'_apply, diagonal_apply_eq, diagonal_apply_eq]
state_before: case inl
l : Type ?u.250274
m : Type ?u.250277
n : Type ?u.250280
o : Type u_1
p : Type ?u.250286
q : Type ?u.250289
m' : o → Type u_2
n' : o → Type ?u.250299
p' : o → Type ?u.250304
R : Type ?u.250307
S : Type ?u.250310
α : Type u_3
β : Type ?u.250316
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : (i : o) → DecidableEq (m' i)
d : (i : o) × m' i → α
k : o
i : m' k
⊢ blockDiag' (diagonal d) k i i = diagonal (fun i => d { fst := k, snd := i }) i i

tactic: rw [blockDiag'_apply, diagonal_apply_ne _ hij, diagonal_apply_ne _ (mt (fun h => ?_) hij)]
state_before: case inr
l : Type ?u.250274
m : Type ?u.250277
n : Type ?u.250280
o : Type u_1
p : Type ?u.250286
q : Type ?u.250289
m' : o → Type u_2
n' : o → Type ?u.250299
p' : o → Type ?u.250304
R : Type ?u.250307
S : Type ?u.250310
α : Type u_3
β : Type ?u.250316
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : (i : o) → DecidableEq (m' i)
d : (i : o) × m' i → α
k : o
i j : m' k
hij : i ≠ j
⊢ blockDiag' (diagonal d) k i j = diagonal (fun i => d { fst := k, snd := i }) i j

tactic: cases h
state_before: l : Type ?u.250274
m : Type ?u.250277
n : Type ?u.250280
o : Type u_1
p : Type ?u.250286
q : Type ?u.250289
m' : o → Type u_2
n' : o → Type ?u.250299
p' : o → Type ?u.250304
R : Type ?u.250307
S : Type ?u.250310
α : Type u_3
β : Type ?u.250316
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : (i : o) → DecidableEq (m' i)
d : (i : o) × m' i → α
k : o
i j : m' k
hij : i ≠ j
h : { fst := k, snd := i } = { fst := k, snd := j }
⊢ i = j

tactic: rfl
state_before: case refl
l : Type ?u.250274
m : Type ?u.250277
n : Type ?u.250280
o : Type u_1
p : Type ?u.250286
q : Type ?u.250289
m' : o → Type u_2
n' : o → Type ?u.250299
p' : o → Type ?u.250304
R : Type ?u.250307
S : Type ?u.250310
α : Type u_3
β : Type ?u.250316
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : DecidableEq o
inst✝ : (i : o) → DecidableEq (m' i)
d : (i : o) × m' i → α
k : o
i : m' k
hij : i ≠ i
⊢ i = i