tasksource/leandojo huggingface dataset:
Theorem: Pi.continuous_curry
File: Mathlib/Control/LawfulFix.lean

tactic: ext (x y)
state_before: α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
⊢ ↑(monotoneCurry α β γ) (ωSup c) = ωSup (Chain.map c (monotoneCurry α β γ))

tactic: dsimp [curry, ωSup]
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ↑(monotoneCurry α β γ) (ωSup c) x y = ωSup (Chain.map c (monotoneCurry α β γ)) x y

tactic: rw [map_comp, map_comp]
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (Chain.map c (evalOrderHom { fst := x, snd := y })) =
    ωSup (Chain.map (Chain.map (Chain.map c (monotoneCurry α β γ)) (evalOrderHom x)) (evalOrderHom y))

tactic: rfl
state_before: case h.h
α : Type u_1
β : α → Type u_2
γ : (a : α) → β a → Type u_3
inst✝ : (x : α) → (y : β x) → OmegaCompletePartialOrder (γ x y)
c : Chain ((x : (a : α) × β a) → γ x.fst x.snd)
x : α
y : β x
⊢ ωSup (Chain.map c (evalOrderHom { fst := x, snd := y })) =
    ωSup (Chain.map c (OrderHom.comp (OrderHom.comp (evalOrderHom y) (evalOrderHom x)) (monotoneCurry α β γ)))
Theorem: LinearMap.trace_transpose'
File: Mathlib/LinearAlgebra/Trace.lean

tactic: rw [← comp_apply, trace_transpose]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type ?u.575799
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.576341
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
f : M →ₗ[R] M
⊢ ↑(trace R (Module.Dual R M)) (↑Module.Dual.transpose f) = ↑(trace R M) f
Theorem: totallyBounded_iff_subset_finite_iUnion_nhds_one
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: simp [← preimage_smul_inv, preimage]
state_before: α : Type u_1
β : Type ?u.337374
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
s : Set α
⊢ (∀ (i : Set α),
      i ∈ 𝓝 1 → ∃ t, Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ {x | x.snd⁻¹ * x.fst ∈ id i}}) ↔
    ∀ (U : Set α), U ∈ 𝓝 1 → ∃ t, Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), y • U
Theorem: ZMod.χ₄_nat_three_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [χ₄_nat_mod_four, hn]
state_before: n : ℕ
hn : n % 4 = 3
⊢ ↑χ₄ ↑n = -1

tactic: rfl
state_before: n : ℕ
hn : n % 4 = 3
⊢ ↑χ₄ ↑3 = -1
Theorem: Computable.vector_ofFn
File: Mathlib/Computability/Partrec.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.209886
γ : Type ?u.209889
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin n → α → σ
hf : ∀ (i : Fin n), Computable (f i)
a : α
⊢ (Vector.mOfFn fun i => ↑(f i) a) = (↑fun a => Vector.ofFn fun i => f i a) a
Theorem: LinearMap.det_toMatrix_eq_det_toMatrix
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: rw [← linearMap_toMatrix_mul_basis_toMatrix c b c, ← basis_toMatrix_mul_linearMap_toMatrix b c b,
    Matrix.det_conj_of_mul_eq_one] <;>
  rw [Basis.toMatrix_mul_toMatrix, Basis.toMatrix_self]
state_before: R : Type ?u.43313
inst✝¹⁰ : CommRing R
M : Type u_4
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.43904
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type u_2
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_3
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type u_1
inst✝¹ : Fintype κ
inst✝ : DecidableEq κ
b : Basis ι A M
c : Basis κ A M
f : M →ₗ[A] M
⊢ det (↑(toMatrix b b) f) = det (↑(toMatrix c c) f)
Theorem: Finsupp.total_option
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [total_apply, sum_option_index_smul, total_apply]
state_before: α : Type u_1
M : Type u_3
N : Type ?u.394504
P : Type ?u.394507
R : Type u_2
S : Type ?u.394513
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.394605
M' : Type ?u.394608
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v✝ : α → M
v' : α' → M'
v : Option α → M
f : Option α →₀ R
⊢ ↑(Finsupp.total (Option α) M R v) f = ↑f none • v none + ↑(Finsupp.total α M R (v ∘ Option.some)) (some f)

tactic: simp
state_before: α : Type u_1
M : Type u_3
N : Type ?u.394504
P : Type ?u.394507
R : Type u_2
S : Type ?u.394513
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.394605
M' : Type ?u.394608
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v✝ : α → M
v' : α' → M'
v : Option α → M
f : Option α →₀ R
⊢ (↑f none • v none + sum (some f) fun a r => r • v (Option.some a)) =
    ↑f none • v none + sum (some f) fun i a => a • (v ∘ Option.some) i
Theorem: Filter.Tendsto.rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: simp [tendsto_const_nhds]
state_before: α : Type u_1
l : Filter α
f : α → ℝ
x p : ℝ
hf : Tendsto f l (𝓝 x)
h : x ≠ 0 ∨ 0 ≤ p
h0 : 0 = p
⊢ Tendsto (fun a => f a ^ 0) l (𝓝 (x ^ 0))
Theorem: CategoryTheory.tensorLeftHomEquiv_symm_coevaluation_comp_id_tensor
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: dsimp [tensorLeftHomEquiv]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ ↑(tensorLeftHomEquiv (𝟙_ C) Y Y' Z).symm (η_ Y Y' ≫ (𝟙 Y ⊗ f)) = (ρ_ Y').hom ≫ f

tactic: rw [id_tensor_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ (𝟙 Y' ⊗ η_ Y Y' ≫ (𝟙 Y ⊗ f)) ≫ (α_ Y' Y Z).inv ≫ (ε_ Y Y' ⊗ 𝟙 Z) ≫ (λ_ Z).hom = (ρ_ Y').hom ≫ f

tactic: slice_lhs 2 3 => rw [associator_inv_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ ((𝟙 Y' ⊗ η_ Y Y') ≫ (𝟙 Y' ⊗ 𝟙 Y ⊗ f)) ≫ (α_ Y' Y Z).inv ≫ (ε_ Y Y' ⊗ 𝟙 Z) ≫ (λ_ Z).hom = (ρ_ Y').hom ≫ f

tactic: slice_lhs 3 4 => rw [tensor_id, id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ (𝟙 Y' ⊗ η_ Y Y') ≫ (((α_ Y' Y Y').inv ≫ ((𝟙 Y' ⊗ 𝟙 Y) ⊗ f)) ≫ (ε_ Y Y' ⊗ 𝟙 Z)) ≫ (λ_ Z).hom = (ρ_ Y').hom ≫ f

tactic: slice_lhs 1 3 => rw [coevaluation_evaluation]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ (𝟙 Y' ⊗ η_ Y Y') ≫ (α_ Y' Y Y').inv ≫ ((ε_ Y Y' ⊗ 𝟙 Y') ≫ (𝟙 (𝟙_ C) ⊗ f)) ≫ (λ_ Z).hom = (ρ_ Y').hom ≫ f

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
Y Y' Z : C
inst✝ : ExactPairing Y Y'
f : Y' ⟶ Z
⊢ (((ρ_ Y').hom ≫ (λ_ Y').inv) ≫ (𝟙 (𝟙_ C) ⊗ f)) ≫ (λ_ Z).hom = (ρ_ Y').hom ≫ f
Theorem: Real.Angle.eq_neg_self_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [← add_eq_zero_iff_eq_neg, ← two_nsmul, two_nsmul_eq_zero_iff]
state_before: θ : Angle
⊢ θ = -θ ↔ θ = 0 ∨ θ = ↑π
Theorem: Finset.one_mem_div_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← mem_coe, ← disjoint_coe, coe_div, Set.one_mem_div_iff]
state_before: F : Type ?u.606313
α : Type u_1
β : Type ?u.606319
γ : Type ?u.606322
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ 1 ∈ s / t ↔ ¬Disjoint s t
Theorem: Option.id_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: cases x <;> rfl
state_before: F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
x : Option α
⊢ Option.traverse pure x = x
Theorem: MeasureTheory.FiniteMeasure.integrable_of_boundedContinuous_to_real
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: refine' ⟨f.continuous.measurable.aestronglyMeasurable, _⟩
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
⊢ Integrable ↑f

tactic: have aux : ((↑) : ℝ≥0 → ℝ) ∘ ⇑f.nnnorm = fun x => ‖f x‖ := by
  ext ω
  simp only [Function.comp_apply, BoundedContinuousFunction.nnnorm_coeFn_eq, coe_nnnorm]
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
⊢ HasFiniteIntegral ↑f

tactic: apply (hasFiniteIntegral_iff_norm f).mpr
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
aux : NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖
⊢ HasFiniteIntegral ↑f

tactic: rw [← ofReal_integral_eq_lintegral_ofReal]
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
aux : NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖
⊢ (∫⁻ (a : Ω), ENNReal.ofReal ‖↑f a‖ ∂μ) < ⊤

tactic: ext ω
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
⊢ NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖

tactic: simp only [Function.comp_apply, BoundedContinuousFunction.nnnorm_coeFn_eq, coe_nnnorm]
state_before: case h
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
ω : Ω
⊢ (NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f)) ω = ‖↑f ω‖

tactic: exact ENNReal.ofReal_lt_top
state_before: Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
aux : NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖
⊢ ENNReal.ofReal (∫ (x : Ω), ‖↑f x‖ ∂μ) < ⊤

tactic: exact aux ▸ integrable_of_boundedContinuous_to_nnreal μ f.nnnorm
state_before: case hfi
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
aux : NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖
⊢ Integrable fun a => ‖↑f a‖

tactic: exact eventually_of_forall fun ω => norm_nonneg (f ω)
state_before: case f_nn
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
f : Ω →ᵇ ℝ
aux : NNReal.toReal ∘ ↑(BoundedContinuousFunction.nnnorm f) = fun x => ‖↑f x‖
⊢ 0 ≤ᵐ[μ] fun a => ‖↑f a‖
Theorem: List.mem_split
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with b l ih
state_before: ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
h : a ∈ l
⊢ ∃ s t, l = s ++ a :: t

tactic: {cases h}
state_before: case nil
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
h✝ : a ∈ l
h : a ∈ []
⊢ ∃ s t, [] = s ++ a :: t

case cons
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l✝ : List α
h✝ : a ∈ l✝
b : α
l : List α
ih : a ∈ l → ∃ s t, l = s ++ a :: t
h : a ∈ b :: l
⊢ ∃ s t, b :: l = s ++ a :: t

tactic: rcases h with (_ | ⟨_, h⟩)
state_before: case cons
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l✝ : List α
h✝ : a ∈ l✝
b : α
l : List α
ih : a ∈ l → ∃ s t, l = s ++ a :: t
h : a ∈ b :: l
⊢ ∃ s t, b :: l = s ++ a :: t

tactic: exact ⟨[], l, rfl⟩
state_before: case cons.head
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l✝ : List α
h : a ∈ l✝
l : List α
ih : a ∈ l → ∃ s t, l = s ++ a :: t
⊢ ∃ s t, a :: l = s ++ a :: t

tactic: rcases ih h with ⟨s, t, rfl⟩
state_before: case cons.tail
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l✝ : List α
h✝ : a ∈ l✝
b : α
l : List α
ih : a ∈ l → ∃ s t, l = s ++ a :: t
h : Mem a l
⊢ ∃ s t, b :: l = s ++ a :: t

tactic: exact ⟨b :: s, t, rfl⟩
state_before: case cons.tail.intro.intro
ι : Type ?u.1166
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
h✝ : a ∈ l
b : α
s t : List α
ih : a ∈ s ++ a :: t → ∃ s_1 t_1, s ++ a :: t = s_1 ++ a :: t_1
h : Mem a (s ++ a :: t)
⊢ ∃ s_1 t_1, b :: (s ++ a :: t) = s_1 ++ a :: t_1
Theorem: List.drop_sum_join
File: Mathlib/Data/List/Join.lean

tactic: induction L generalizing i
state_before: α : Type u_1
β : Type ?u.6451
L : List (List α)
i : ℕ
⊢ drop (sum (take i (map length L))) (join L) = join (drop i L)

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.6451
i : ℕ
⊢ drop (sum (take i (map length []))) (join []) = join (drop i [])

tactic: cases i <;> simp [drop_append, *]
state_before: case cons
α : Type u_1
β : Type ?u.6451
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : ∀ (i : ℕ), drop (sum (take i (map length tail✝))) (join tail✝) = join (drop i tail✝)
i : ℕ
⊢ drop (sum (take i (map length (head✝ :: tail✝)))) (join (head✝ :: tail✝)) = join (drop i (head✝ :: tail✝))
Theorem: IsCyclic.image_range_orderOf
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: simp_rw [← SetLike.mem_coe] at ha
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ zpowers a
⊢ image (fun i => a ^ i) (range (orderOf a)) = univ

tactic: simp only [_root_.image_range_orderOf, Set.eq_univ_iff_forall.mpr ha, Set.toFinset_univ]
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
ha : ∀ (x : α), x ∈ ↑(zpowers a)
⊢ image (fun i => a ^ i) (range (orderOf a)) = univ
Theorem: Function.update_idem
File: Mathlib/Logic/Function/Basic.lean

tactic: funext b
state_before: α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g : (a : α✝) → β✝ a
a✝ : α✝
b : β✝ a✝
α : Sort u_1
inst✝ : DecidableEq α
β : α → Sort u_2
a : α
v w : β a
f : (a : α) → β a
⊢ update (update f a v) a w = update f a w

tactic: by_cases h : b = a <;> simp [update, h]
state_before: case h
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g : (a : α✝) → β✝ a
a✝ : α✝
b✝ : β✝ a✝
α : Sort u_1
inst✝ : DecidableEq α
β : α → Sort u_2
a : α
v w : β a
f : (a : α) → β a
b : α
⊢ update (update f a v) a w b = update f a w b
Theorem: AlgHom.FinitePresentation.of_surjective
File: Mathlib/RingTheory/FinitePresentation.lean

tactic: convert RingHom.FinitePresentation.of_surjective f hf hker
state_before: R : Type u_1
A : Type u_2
B : Type u_3
C : Type ?u.1176485
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing B
inst✝³ : CommRing C
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f : A →ₐ[R] B
hf : Surjective ↑f
hker : Ideal.FG (RingHom.ker ↑f)
⊢ FinitePresentation f
Theorem: list_casesOn'
File: Mathlib/Computability/Primrec.lean

tactic: cases' f a with b l <;> simp [encodek]
state_before: α : Type u_2
β : Type u_1
σ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
H : Nat.Primrec fun n => encode (decode n)
f : α → List β
g : α → σ
h : α → β × List β → σ
hf : Primrec f
hg : Primrec g
hh : Primrec₂ h
this✝ : Primcodable (List β) := prim H
this : Primrec fun a => Option.map (fun o => Option.casesOn o (g a) (h a)) (decode (encode (f a)))
a : α
⊢ Option.map (fun o => Option.casesOn o (g a) (h a)) (decode (encode (f a))) =
    some (List.casesOn (f a) (g a) fun b l => h a (b, l))
Theorem: Zspan.fundamentalDomain_bounded
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: cases nonempty_fintype ι
state_before: E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
⊢ Metric.Bounded (fundamentalDomain b)

tactic: use 2 * ∑ j, ‖b j‖
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
⊢ Metric.Bounded (fundamentalDomain b)

tactic: intro x hx y hy
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
⊢ ∀ (x : E), x ∈ fundamentalDomain b → ∀ (y : E), y ∈ fundamentalDomain b → dist x y ≤ 2 * ∑ j : ι, ‖↑b j‖

tactic: refine le_trans (dist_le_norm_add_norm x y) ?_
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
x : E
hx : x ∈ fundamentalDomain b
y : E
hy : y ∈ fundamentalDomain b
⊢ dist x y ≤ 2 * ∑ j : ι, ‖↑b j‖

tactic: rw [← fract_eq_self.mpr hx, ← fract_eq_self.mpr hy]
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
x : E
hx : x ∈ fundamentalDomain b
y : E
hy : y ∈ fundamentalDomain b
⊢ ‖x‖ + ‖y‖ ≤ 2 * ∑ j : ι, ‖↑b j‖

tactic: refine (add_le_add (norm_fract_le b x) (norm_fract_le b y)).trans ?_
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
x : E
hx : x ∈ fundamentalDomain b
y : E
hy : y ∈ fundamentalDomain b
⊢ ‖fract b x‖ + ‖fract b y‖ ≤ 2 * ∑ j : ι, ‖↑b j‖

tactic: rw [← two_mul]
state_before: case intro
E : Type u_3
ι : Type u_1
K : Type u_2
inst✝⁵ : NormedLinearOrderedField K
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
b : Basis ι K E
inst✝² : FloorRing K
inst✝¹ : Finite ι
inst✝ : HasSolidNorm K
val✝ : Fintype ι
x : E
hx : x ∈ fundamentalDomain b
y : E
hy : y ∈ fundamentalDomain b
⊢ ∑ i : ι, ‖↑b i‖ + ∑ i : ι, ‖↑b i‖ ≤ 2 * ∑ j : ι, ‖↑b j‖
Theorem: Finset.comp_sup_eq_sup_comp
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [sup_cons, sup_cons, g_sup, ih, Function.comp_apply]
state_before: F : Type ?u.63465
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.63477
κ : Type ?u.63480
inst✝³ : SemilatticeSup α
inst✝² : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g✝ : β → α
a : α
inst✝¹ : SemilatticeSup γ
inst✝ : OrderBot γ
s : Finset β
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
bot : g ⊥ = ⊥
c : β
t : Finset β
hc : ¬c ∈ t
ih : g (sup t f) = sup t (g ∘ f)
⊢ g (sup (cons c t hc) f) = sup (cons c t hc) (g ∘ f)
Theorem: ConvexIndependent.range
File: Mathlib/Analysis/Convex/Independent.lean

tactic: let f : Set.range p → ι := fun x => x.property.choose
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
⊢ ConvexIndependent 𝕜 Subtype.val

tactic: have hf : ∀ x, p (f x) = x := fun x => x.property.choose_spec
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
f : ↑(Set.range p) → ι := fun x => Exists.choose (_ : ↑x ∈ Set.range p)
⊢ ConvexIndependent 𝕜 Subtype.val

tactic: let fe : Set.range p ↪ ι := ⟨f, fun x₁ x₂ he => Subtype.ext (hf x₁ ▸ hf x₂ ▸ he ▸ rfl)⟩
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
f : ↑(Set.range p) → ι := fun x => Exists.choose (_ : ↑x ∈ Set.range p)
hf : ∀ (x : ↑(Set.range p)), p (f x) = ↑x
⊢ ConvexIndependent 𝕜 Subtype.val

tactic: convert hc.comp_embedding fe
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
f : ↑(Set.range p) → ι := fun x => Exists.choose (_ : ↑x ∈ Set.range p)
hf : ∀ (x : ↑(Set.range p)), p (f x) = ↑x
fe : ↑(Set.range p) ↪ ι := { toFun := f, inj' := (_ : ∀ (x₁ x₂ : ↑(Set.range p)), f x₁ = f x₂ → x₁ = x₂) }
⊢ ConvexIndependent 𝕜 Subtype.val

tactic: ext
state_before: case h.e'_7
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
f : ↑(Set.range p) → ι := fun x => Exists.choose (_ : ↑x ∈ Set.range p)
hf : ∀ (x : ↑(Set.range p)), p (f x) = ↑x
fe : ↑(Set.range p) ↪ ι := { toFun := f, inj' := (_ : ∀ (x₁ x₂ : ↑(Set.range p)), f x₁ = f x₂ → x₁ = x₂) }
⊢ Subtype.val = p ∘ ↑fe

tactic: rw [Embedding.coeFn_mk, comp_apply, hf]
state_before: case h.e'_7.h
𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
p : ι → E
hc : ConvexIndependent 𝕜 p
f : ↑(Set.range p) → ι := fun x => Exists.choose (_ : ↑x ∈ Set.range p)
hf : ∀ (x : ↑(Set.range p)), p (f x) = ↑x
fe : ↑(Set.range p) ↪ ι := { toFun := f, inj' := (_ : ∀ (x₁ x₂ : ↑(Set.range p)), f x₁ = f x₂ → x₁ = x₂) }
x✝ : { x // x ∈ Set.range p }
⊢ ↑x✝ = (p ∘ ↑fe) x✝
Theorem: Nat.div_mul_cancel
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.mul_comm, Nat.mul_div_cancel' H]
state_before: n m : Nat
H : n ∣ m
⊢ m / n * n = m
Theorem: Basis.coord_repr_symm
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp only [repr_symm_apply, coord_apply, repr_total]
state_before: ι : Type u_1
ι' : Type ?u.177420
R : Type u_2
R₂ : Type ?u.177426
K : Type ?u.177429
M : Type u_3
M' : Type ?u.177435
M'' : Type ?u.177438
V : Type u
V' : Type ?u.177443
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b✝ b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b : Basis ι R M
i : ι
f : ι →₀ R
⊢ ↑(coord b i) (↑(LinearEquiv.symm b.repr) f) = ↑f i
Theorem: CategoryTheory.Presieve.restrict_extend
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: funext Y f hf
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
t : FamilyOfElements.Compatible x
⊢ FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) (FamilyOfElements.sieveExtend x) = x

tactic: exact extend_agrees t hf
state_before: case h.h.h
C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y✝ : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
x : FamilyOfElements P R
t : FamilyOfElements.Compatible x
Y : C
f : Y ⟶ X
hf : R f
⊢ FamilyOfElements.restrict (_ : R ≤ (generate R).arrows) (FamilyOfElements.sieveExtend x) f hf = x f hf
Theorem: MvPolynomial.degreeOf_C
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical simp [degreeOf_def, degrees_C]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.286346
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
x : σ
⊢ degreeOf x (↑C a) = 0

tactic: simp [degreeOf_def, degrees_C]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.286346
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
a : R
x : σ
⊢ degreeOf x (↑C a) = 0