tasksource/leandojo huggingface dataset:
Theorem: ClosureOperator.eq_mk₃_closed
File: Mathlib/Order/Closure.lean

tactic: ext
state_before: α : Type u_1
ι : Sort ?u.6048
κ : ι → Sort ?u.6053
inst✝¹ inst✝ : PartialOrder α
c✝ c : ClosureOperator α
⊢ c =
    mk₃ (↑c.toOrderHom) (closed c) (_ : ∀ (x : α), x ≤ ↑c.toOrderHom x) (_ : ∀ (x : α), ↑c.toOrderHom x ∈ closed c)
      (_ : ∀ (x y : α), x ≤ y → closed c y → ↑c.toOrderHom x ≤ y)

tactic: rfl
state_before: case a.h
α : Type u_1
ι : Sort ?u.6048
κ : ι → Sort ?u.6053
inst✝¹ inst✝ : PartialOrder α
c✝ c : ClosureOperator α
x✝ : α
⊢ ↑c.toOrderHom x✝ =
    ↑(mk₃ (↑c.toOrderHom) (closed c) (_ : ∀ (x : α), x ≤ ↑c.toOrderHom x) (_ : ∀ (x : α), ↑c.toOrderHom x ∈ closed c)
            (_ : ∀ (x y : α), x ≤ y → closed c y → ↑c.toOrderHom x ≤ y)).toOrderHom
      x✝
Theorem: Set.toFinset_diff
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.88416
γ : Type ?u.88419
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s \ t)
⊢ toFinset (s \ t) = toFinset s \ toFinset t

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.88416
γ : Type ?u.88419
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s \ t)
a✝ : α
⊢ a✝ ∈ toFinset (s \ t) ↔ a✝ ∈ toFinset s \ toFinset t
Theorem: MeasureTheory.OuterMeasure.toMeasure_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← Measure.measure_univ_eq_zero, toMeasure_apply _ _ MeasurableSet.univ,
  OuterMeasure.coe_zero, Pi.zero_apply]
state_before: α : Type u_1
β : Type ?u.3495308
γ : Type ?u.3495311
δ : Type ?u.3495314
ι : Type ?u.3495317
R : Type ?u.3495320
R' : Type ?u.3495323
inst✝ : MeasurableSpace α
⊢ toMeasure 0 (_ : inst✝ ≤ OuterMeasure.caratheodory 0) = 0
Theorem: AbsoluteValue.map_units_int_cast
File: Mathlib/Data/Int/AbsoluteValue.lean

tactic: rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : LinearOrderedCommRing S
inst✝ : Nontrivial R
abv : AbsoluteValue R S
x : ℤˣ
⊢ ↑abv ↑↑x = 1
Theorem: set_smul_mem_nhds_smul_iff
File: Mathlib/Topology/Algebra/ConstMulAction.lean

tactic: refine' ⟨fun h => _, fun h => set_smul_mem_nhds_smul h hc⟩
state_before: M : Type ?u.165207
α : Type u_1
β : Type ?u.165213
Γ : Type ?u.165216
inst✝⁶ : Group Γ
T : Type ?u.165222
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hc : c ≠ 0
⊢ c • s ∈ 𝓝 (c • x) ↔ s ∈ 𝓝 x

tactic: rw [← inv_smul_smul₀ hc x, ← inv_smul_smul₀ hc s]
state_before: M : Type ?u.165207
α : Type u_1
β : Type ?u.165213
Γ : Type ?u.165216
inst✝⁶ : Group Γ
T : Type ?u.165222
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hc : c ≠ 0
h : c • s ∈ 𝓝 (c • x)
⊢ s ∈ 𝓝 x

tactic: exact set_smul_mem_nhds_smul h (inv_ne_zero hc)
state_before: M : Type ?u.165207
α : Type u_1
β : Type ?u.165213
Γ : Type ?u.165216
inst✝⁶ : Group Γ
T : Type ?u.165222
inst✝⁵ : TopologicalSpace T
inst✝⁴ : MulAction Γ T
G₀ : Type u_2
inst✝³ : GroupWithZero G₀
inst✝² : MulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
c : G₀
s : Set α
x : α
hc : c ≠ 0
h : c • s ∈ 𝓝 (c • x)
⊢ c⁻¹ • c • s ∈ 𝓝 (c⁻¹ • c • x)
Theorem: UniformFun.hasBasis_nhds_one_of_basis
File: Mathlib/Topology/Algebra/UniformConvergence.lean

tactic: have := h.comap fun p : G × G => p.2 / p.1
state_before: α : Type u_3
G : Type u_1
ι : Type u_2
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), f x ∈ b i}

tactic: rw [← uniformity_eq_comap_nhds_one] at this
state_before: α : Type u_3
G : Type u_1
ι : Type u_2
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (comap (fun p => p.snd / p.fst) (𝓝 1)) p fun i => (fun p => p.snd / p.fst) ⁻¹' b i
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), f x ∈ b i}

tactic: convert UniformFun.hasBasis_nhds_of_basis α _ (1 : α →ᵤ G) this
state_before: α : Type u_3
G : Type u_1
ι : Type u_2
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.snd / p.fst) ⁻¹' b i
⊢ HasBasis (𝓝 1) p fun i => {f | ∀ (x : α), f x ∈ b i}

tactic: simp [UniformFun.gen]
state_before: case h.e'_5.h.h.e'_2.h.a
α : Type u_3
G : Type u_1
ι : Type u_2
inst✝² : Group G
𝔖 : Set (Set α)
inst✝¹ : UniformSpace G
inst✝ : UniformGroup G
p : ι → Prop
b : ι → Set G
h : HasBasis (𝓝 1) p b
this : HasBasis (uniformity G) p fun i => (fun p => p.snd / p.fst) ⁻¹' b i
x✝¹ : ι
x✝ : α →ᵤ G
⊢ (∀ (x : α), x✝ x ∈ b x✝¹) ↔ (1, x✝) ∈ UniformFun.gen α G ((fun p => p.snd / p.fst) ⁻¹' b x✝¹)
Theorem: LatticeOrderedCommGroup.neg_le_one_iff
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [m_neg_part_def, sup_le_iff, and_iff_left le_rfl]
state_before: α : Type u
inst✝¹ : Lattice α
inst✝ : CommGroup α
a : α
⊢ a⁻ ≤ 1 ↔ a⁻¹ ≤ 1
Theorem: Finmap.insert_insert_of_ne
File: Mathlib/Data/Finmap.lean

tactic: simp only [insert_toFinmap, AList.toFinmap_eq, AList.insert_insert_of_ne _ h]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
b : β a
b' : β a'
s✝ : Finmap β
h : a ≠ a'
s : AList β
⊢ insert a' b' (insert a b ⟦s⟧) = insert a b (insert a' b' ⟦s⟧)
Theorem: Pi.card_Ioi
File: Mathlib/Data/Pi/Interval.lean

tactic: rw [card_Ioi_eq_card_Ici_sub_one, card_Ici]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : (i : ι) → LocallyFiniteOrderTop (α i)
a : (i : ι) → α i
⊢ Finset.card (Ioi a) = ∏ i : ι, Finset.card (Ici (a i)) - 1
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.mk
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: intro s hs
state_before: α : Type u_1
β : Type ?u.397362
γ : Type ?u.397365
δ : Type ?u.397368
ι : Type ?u.397371
R : Type ?u.397374
R' : Type ?u.397377
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑↑ν s = 0 → ↑↑μ s = 0
⊢ μ ≪ ν

tactic: rcases exists_measurable_superset_of_null hs with ⟨t, h1t, h2t, h3t⟩
state_before: α : Type u_1
β : Type ?u.397362
γ : Type ?u.397365
δ : Type ?u.397368
ι : Type ?u.397371
R : Type ?u.397374
R' : Type ?u.397377
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑↑ν s = 0 → ↑↑μ s = 0
s : Set α
hs : ↑↑ν s = 0
⊢ ↑↑μ s = 0

tactic: exact measure_mono_null h1t (h h2t h3t)
state_before: case intro.intro.intro
α : Type u_1
β : Type ?u.397362
γ : Type ?u.397365
δ : Type ?u.397368
ι : Type ?u.397371
R : Type ?u.397374
R' : Type ?u.397377
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑↑ν s = 0 → ↑↑μ s = 0
s : Set α
hs : ↑↑ν s = 0
t : Set α
h1t : s ⊆ t
h2t : MeasurableSet t
h3t : ↑↑ν t = 0
⊢ ↑↑μ s = 0
Theorem: SequentiallyComplete.setSeq_prod_subset
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: refine' (setSeqAux hf U_mem N).2.2 ⟨_, _⟩ <;> apply setSeq_sub_aux
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p ∈ U N

tactic: exact setSeq_mono hf U_mem hm hp.1
state_before: case refine'_1.a
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.fst ∈ setSeq hf U_mem N

case refine'_2.a
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.snd ∈ setSeq hf U_mem N

tactic: exact setSeq_mono hf U_mem hn hp.2
state_before: case refine'_2.a
α : Type u
β : Type v
inst✝ : UniformSpace α
f : Filter α
hf : Cauchy f
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
U_le : ∀ (s : Set (α × α)), s ∈ 𝓤 α → ∃ n, U n ⊆ s
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
p : α × α
hp : p ∈ setSeq hf U_mem m ×ˢ setSeq hf U_mem n
⊢ p.snd ∈ setSeq hf U_mem N
Theorem: MeasurableSet.tProd
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: induction' l with i l ih
state_before: α : Type ?u.373293
β : Type ?u.373296
γ : Type ?u.373299
δ : Type u_1
δ' : Type ?u.373305
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
l : List δ
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
⊢ MeasurableSet (Set.tprod l s)

tactic: exact MeasurableSet.univ
state_before: case nil
α : Type ?u.373293
β : Type ?u.373296
γ : Type ?u.373299
δ : Type u_1
δ' : Type ?u.373305
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
⊢ MeasurableSet (Set.tprod [] s)

case cons
α : Type ?u.373293
β : Type ?u.373296
γ : Type ?u.373299
δ : Type u_1
δ' : Type ?u.373305
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
i : δ
l : List δ
ih : MeasurableSet (Set.tprod l s)
⊢ MeasurableSet (Set.tprod (i :: l) s)

tactic: exact (hs i).prod ih
state_before: case cons
α : Type ?u.373293
β : Type ?u.373296
γ : Type ?u.373299
δ : Type u_1
δ' : Type ?u.373305
ι : Sort uι
s✝ t u : Set α
π : δ → Type u_2
inst✝ : (x : δ) → MeasurableSpace (π x)
s : (i : δ) → Set (π i)
hs : ∀ (i : δ), MeasurableSet (s i)
i : δ
l : List δ
ih : MeasurableSet (Set.tprod l s)
⊢ MeasurableSet (Set.tprod (i :: l) s)
Theorem: MeasureTheory.exists_nat_measurableEquiv_range_coe_fin_of_finite
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: obtain ⟨n, ⟨n_equiv⟩⟩ := Finite.exists_equiv_fin α
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
ι : Type ?u.343332
inst✝³ : MeasurableSpace α
inst✝² : PolishSpace α
inst✝¹ : BorelSpace α
inst✝ : Finite α
⊢ ∃ n, Nonempty (α ≃ᵐ ↑(range fun x => ↑↑x))

tactic: refine' ⟨n, ⟨PolishSpace.Equiv.measurableEquiv (n_equiv.trans _)⟩⟩
state_before: case intro.intro
α : Type u_1
inst✝⁴ : TopologicalSpace α
ι : Type ?u.343332
inst✝³ : MeasurableSpace α
inst✝² : PolishSpace α
inst✝¹ : BorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ ∃ n, Nonempty (α ≃ᵐ ↑(range fun x => ↑↑x))

tactic: exact Equiv.ofInjective _ (Nat.cast_injective.comp Fin.val_injective)
state_before: case intro.intro
α : Type u_1
inst✝⁴ : TopologicalSpace α
ι : Type ?u.343332
inst✝³ : MeasurableSpace α
inst✝² : PolishSpace α
inst✝¹ : BorelSpace α
inst✝ : Finite α
n : ℕ
n_equiv : α ≃ Fin n
⊢ Fin n ≃ ↑(range fun x => ↑↑x)
Theorem: MvPolynomial.pderiv_X_self
File: Mathlib/Data/MvPolynomial/PDeriv.lean

tactic: classical simp
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
⊢ ↑(pderiv i) (X i) = 1

tactic: simp
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
⊢ ↑(pderiv i) (X i) = 1
Theorem: MeasureTheory.Measure.restrict_toMeasurable_of_sigmaFinite
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [restrict_apply ht, inter_comm t, measure_toMeasurable_inter_of_sigmaFinite ht,
  restrict_apply ht, inter_comm t]
state_before: α : Type u_1
β : Type ?u.755823
γ : Type ?u.755826
δ : Type ?u.755829
ι : Type ?u.755832
R : Type ?u.755835
R' : Type ?u.755838
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : SigmaFinite μ
s t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ (toMeasurable μ s)) t = ↑↑(restrict μ s) t
Theorem: Equiv.Perm.IsCycle.of_zpow
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: cases n
state_before: ι : Type ?u.1087130
α : Type u_1
β : Type ?u.1087136
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
n : ℤ
h1 : IsCycle (f ^ n)
h2 : support f ⊆ support (f ^ n)
⊢ IsCycle f

tactic: exact h1.of_pow h2
state_before: case ofNat
ι : Type ?u.1087130
α : Type u_1
β : Type ?u.1087136
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
a✝ : ℕ
h1 : IsCycle (f ^ Int.ofNat a✝)
h2 : support f ⊆ support (f ^ Int.ofNat a✝)
⊢ IsCycle f

tactic: simp only [le_eq_subset, zpow_negSucc, Perm.support_inv] at h1 h2
state_before: case negSucc
ι : Type ?u.1087130
α : Type u_1
β : Type ?u.1087136
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
a✝ : ℕ
h1 : IsCycle (f ^ Int.negSucc a✝)
h2 : support f ⊆ support (f ^ Int.negSucc a✝)
⊢ IsCycle f

tactic: exact (inv_inv (f ^ _) ▸ h1.inv).of_pow h2
state_before: case negSucc
ι : Type ?u.1087130
α : Type u_1
β : Type ?u.1087136
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
a✝ : ℕ
h1 : IsCycle (f ^ (a✝ + 1))⁻¹
h2 : support f ⊆ support (f ^ (a✝ + 1))
⊢ IsCycle f
Theorem: CategoryTheory.rightDualIso_id
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ rightDualIso p p = Iso.refl Y

tactic: simp only [rightDualIso, Iso.refl_hom, @rightAdjointMate_id _ _ _ _ ⟨Y⟩]
state_before: case w
C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
p : ExactPairing X Y
⊢ (rightDualIso p p).hom = (Iso.refl Y).hom
Theorem: Turing.TM2to1.step_run
File: Mathlib/Computability/TuringMachine.lean

tactic: unfold stWrite
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S =
    TM2.stepAux q (stVar v (S k) (StAct.peek f)) (update S k (stWrite v (S k) (StAct.peek f)))

tactic: rw [Function.update_eq_self]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S =
    TM2.stepAux q (stVar v (S k) (StAct.peek f))
      (update S k
        (match StAct.peek f with
        | StAct.push f => f v :: S k
        | StAct.peek a => S k
        | StAct.pop a => List.tail (S k)))

tactic: rfl
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
inst✝¹ : Inhabited Λ
σ : Type u_4
inst✝ : Inhabited σ
k : K
q : Stmt₂
v : σ
S : (k : K) → List (Γ k)
f : σ → Option (Γ k) → σ
⊢ TM2.stepAux (stRun (StAct.peek f) q) v S = TM2.stepAux q (stVar v (S k) (StAct.peek f)) S
Theorem: Dense.eq_zero_of_inner_left
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [inner_zero_left, h v]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.899657
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
inst✝ : CompleteSpace E
hK : Dense ↑K
h : ∀ (v : { x // x ∈ K }), inner x ↑v = 0
v : { x // x ∈ K }
⊢ inner x ↑v = inner 0 ↑v
Theorem: Submodule.span_sup
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [Submodule.span_union, p.span_eq]
state_before: R : Type u_2
R₂ : Type ?u.49517
K : Type ?u.49520
M : Type u_1
M₂ : Type ?u.49526
V : Type ?u.49529
S : Type ?u.49532
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ span R s ⊔ p = span R (s ∪ ↑p)
Theorem: le_partialSups_of_le
File: Mathlib/Order/PartialSups.lean

tactic: induction' n with n ih
state_before: α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
m n : ℕ
h : m ≤ n
⊢ f m ≤ ↑(partialSups f) n

tactic: rw [nonpos_iff_eq_zero.mp h, partialSups_zero]
state_before: case zero
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
m n : ℕ
h✝ : m ≤ n
h : m ≤ Nat.zero
⊢ f m ≤ ↑(partialSups f) Nat.zero

tactic: cases' h with h h
state_before: case succ
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
m n✝ : ℕ
h✝ : m ≤ n✝
n : ℕ
ih : m ≤ n → f m ≤ ↑(partialSups f) n
h : m ≤ Nat.succ n
⊢ f m ≤ ↑(partialSups f) (Nat.succ n)

tactic: exact le_sup_right
state_before: case succ.refl
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
n✝ n : ℕ
h : Nat.succ n ≤ n✝
ih : Nat.succ n ≤ n → f (Nat.succ n) ≤ ↑(partialSups f) n
⊢ f (Nat.succ n) ≤ ↑(partialSups f) (Nat.succ n)

tactic: exact (ih h).trans le_sup_left
state_before: case succ.step
α : Type u_1
inst✝ : SemilatticeSup α
f : ℕ → α
m n✝ : ℕ
h✝ : m ≤ n✝
n : ℕ
ih : m ≤ n → f m ≤ ↑(partialSups f) n
h : Nat.le m n
⊢ f m ≤ ↑(partialSups f) (Nat.succ n)
Theorem: ENNReal.inv_lt_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [lt_top_iff_ne_top, inv_ne_top, pos_iff_ne_zero]
state_before: α : Type ?u.255378
β : Type ?u.255381
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ x⁻¹ < ⊤ ↔ 0 < x
Theorem: UInt64.sizeOf
File: src/lean/Init/SizeOfLemmas.lean

tactic: cases a
state_before: a : UInt64
⊢ SizeOf.sizeOf a = toNat a + 2

tactic: simp_arith [UInt64.toNat]
state_before: case mk
val✝ : Fin size
⊢ SizeOf.sizeOf { val := val✝ } = toNat { val := val✝ } + 2
Theorem: Polynomial.dickson_one_one_eval_add_inv
File: Mathlib/RingTheory/Polynomial/Dickson.lean

tactic: suffices eval (x + y) 2 = 2 by convert this <;> norm_num
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (dickson 1 1 0) = x ^ 0 + y ^ 0

tactic: exact eval_nat_cast
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) 2 = 2

tactic: convert this <;> norm_num
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
this : eval (x + y) 2 = 2
⊢ eval (x + y) (dickson 1 1 0) = x ^ 0 + y ^ 0

tactic: simp only [eval_X, dickson_one, pow_one]
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
⊢ eval (x + y) (dickson 1 1 1) = x ^ 1 + y ^ 1

tactic: simp only [eval_sub, eval_mul, dickson_one_one_eval_add_inv x y h _, eval_X, dickson_add_two,
  C_1, eval_one]
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ eval (x + y) (dickson 1 1 (n + 2)) = x ^ (n + 2) + y ^ (n + 2)

tactic: conv_lhs => simp only [pow_succ, add_mul, mul_add, h, ← mul_assoc, mul_comm y x, one_mul]
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ (x + y) * (x ^ (n + 1) + y ^ (n + 1)) - 1 * (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)

tactic: ring
state_before: R : Type u_1
S : Type ?u.117133
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a x y : R
h : x * y = 1
n : ℕ
⊢ x * x * x ^ n + x ^ n + (y ^ n + y * y * y ^ n) - (x ^ n + y ^ n) = x ^ (n + 2) + y ^ (n + 2)
Theorem: CategoryTheory.Adjunction.unit_leftAdjointUniq_hom_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: rw [← unit_leftAdjointUniq_hom adj1 adj2]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((leftAdjointUniq adj1 adj2).hom.app x) = adj2.unit.app x

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
x : C
⊢ adj1.unit.app x ≫ G.map ((leftAdjointUniq adj1 adj2).hom.app x) =
    (adj1.unit ≫ whiskerRight (leftAdjointUniq adj1 adj2).hom G).app x
Theorem: Algebra.smul_leftMulMatrix_algebraMap
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: ext (⟨i, k⟩⟨j, k'⟩)
state_before: R : Type u_1
S : Type u_5
T : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Ring T
inst✝⁷ : Algebra R S
inst✝⁶ : Algebra S T
inst✝⁵ : Algebra R T
inst✝⁴ : IsScalarTower R S T
m : Type u_2
n : Type u_3
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
b : Basis m R S
c : Basis n S T
x : S
⊢ ↑(leftMulMatrix (Basis.smul b c)) (↑(algebraMap S T) x) = blockDiagonal fun x_1 => ↑(leftMulMatrix b) x

tactic: rw [smul_leftMulMatrix, AlgHom.commutes, blockDiagonal_apply, algebraMap_matrix_apply]
state_before: case a.mk.h.mk
R : Type u_1
S : Type u_5
T : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Ring T
inst✝⁷ : Algebra R S
inst✝⁶ : Algebra S T
inst✝⁵ : Algebra R T
inst✝⁴ : IsScalarTower R S T
m : Type u_2
n : Type u_3
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
b : Basis m R S
c : Basis n S T
x : S
i : m
k : n
j : m
k' : n
⊢ ↑(leftMulMatrix (Basis.smul b c)) (↑(algebraMap S T) x) (i, k) (j, k') =
    blockDiagonal (fun x_1 => ↑(leftMulMatrix b) x) (i, k) (j, k')

tactic: split_ifs with h <;> simp only at h <;> simp [h]
state_before: case a.mk.h.mk
R : Type u_1
S : Type u_5
T : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Ring T
inst✝⁷ : Algebra R S
inst✝⁶ : Algebra S T
inst✝⁵ : Algebra R T
inst✝⁴ : IsScalarTower R S T
m : Type u_2
n : Type u_3
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
b : Basis m R S
c : Basis n S T
x : S
i : m
k : n
j : m
k' : n
⊢ ↑(leftMulMatrix b) (if (i, k).snd = (j, k').snd then ↑(algebraMap S S) x else 0) (i, k).fst (j, k').fst =
    if (i, k).snd = (j, k').snd then ↑(leftMulMatrix b) x (i, k).fst (j, k').fst else 0
Theorem: UniqueMul.exists_iff_exists_existsUnique
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: have h' := h
state_before: G : Type u_1
H : Type ?u.9715
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
g : G
h : ∃! ab x, ab.fst * ab.snd = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: rcases h' with ⟨⟨a, b⟩, ⟨hab, rfl, -⟩, -⟩
state_before: G : Type u_1
H : Type ?u.9715
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
g : G
h h' : ∃! ab x, ab.fst * ab.snd = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: cases' Finset.mem_product.mp hab with ha hb
state_before: case intro.mk.intro.intro.intro
G : Type u_1
H : Type ?u.9715
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab x, ab.fst * ab.snd = (a, b).fst * (a, b).snd
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: exact ⟨a, b, ha, hb, (iff_existsUnique ha hb).mpr h⟩
state_before: case intro.mk.intro.intro.intro.intro
G : Type u_1
H : Type ?u.9715
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab x, ab.fst * ab.snd = (a, b).fst * (a, b).snd
ha : (a, b).fst ∈ A
hb : (a, b).snd ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
Theorem: Polynomial.degree_mul_X_pow
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp [(monic_X_pow n).degree_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
⊢ degree (p * X ^ n) = degree p + ↑n