tasksource/leandojo huggingface dataset:
Theorem: InnerProductGeometry.cos_eq_one_iff_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← cos_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = 1 ↔ angle x y = 0

tactic: exact injOn_cos.eq_iff ⟨angle_nonneg x y, angle_le_pi x y⟩ (left_mem_Icc.2 pi_pos.le)
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ cos (angle x y) = cos 0 ↔ angle x y = 0
Theorem: Submodule.iInf_comap_proj
File: Mathlib/LinearAlgebra/Pi.lean

tactic: ext x
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
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x : (i : ι) → φ i
⊢ (⨅ (i : ι), comap (proj i) (p i)) = pi Set.univ p

tactic: simp
state_before: case h
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
ι' : Type x'
inst✝² : Semiring R
φ : ι → Type u_1
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
I : Set ι
p q : (i : ι) → Submodule R (φ i)
x✝ x : (i : ι) → φ i
⊢ (x ∈ ⨅ (i : ι), comap (proj i) (p i)) ↔ x ∈ pi Set.univ p
Theorem: Rack.self_invAct_eq_iff_eq
File: Mathlib/Algebra/Quandle.lean

tactic: have h := @self_act_eq_iff_eq _ _ (op x) (op y)
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y

tactic: simpa using h
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : op x ◃ op x = op y ◃ op y ↔ op x = op y
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
Theorem: Finset.mem_compl
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [compl_eq_univ_sdiff]
state_before: α : Type u_1
β : Type ?u.7802
γ : Type ?u.7805
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a : α
⊢ a ∈ sᶜ ↔ ¬a ∈ s
Theorem: FiniteDimensional.finrank_eq_card_chooseBasisIndex
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: letI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
⊢ finrank R M = card (ChooseBasisIndex R M)

tactic: simp [finrank, rank_eq_card_chooseBasisIndex]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ finrank R M = card (ChooseBasisIndex R M)
Theorem: CategoryTheory.MonoidalCategory.id_tensor_associator_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_id, associator_inv_naturality]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X Y Z X' : C
f : X ⟶ X'
⊢ (f ⊗ 𝟙 (Y ⊗ Z)) ≫ (α_ X' Y Z).inv = (α_ X Y Z).inv ≫ ((f ⊗ 𝟙 Y) ⊗ 𝟙 Z)
Theorem: Set.toFinset_compl
File: Mathlib/Data/Fintype/Basic.lean

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

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.90549
γ : Type ?u.90552
s t : Set α
inst✝⁴ : DecidableEq α
inst✝³ : Fintype ↑s
inst✝² : Fintype ↑t
inst✝¹ : Fintype α
inst✝ : Fintype ↑(sᶜ)
a✝ : α
⊢ a✝ ∈ toFinset (sᶜ) ↔ a✝ ∈ toFinset sᶜ
Theorem: Set.one_lt_ncard
File: Mathlib/Data/Set/Ncard.lean

tactic: simp_rw [ncard_eq_toFinset_card _ hs, Finset.one_lt_card, Finite.mem_toFinset]
state_before: α : Type u_1
β : Type ?u.156100
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ 1 < ncard s ↔ ∃ a, a ∈ s ∧ ∃ b, b ∈ s ∧ a ≠ b
Theorem: Set.PairwiseDisjoint.image_finset_of_le
File: Mathlib/Data/Finset/Pairwise.lean

tactic: rw [coe_image]
state_before: α : Type u_2
ι : Type u_1
ι' : Type ?u.1728
inst✝² : DecidableEq ι
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
hs : PairwiseDisjoint (↑s) f
g : ι → ι
hf : ∀ (a : ι), f (g a) ≤ f a
⊢ PairwiseDisjoint (↑(Finset.image g s)) f

tactic: exact hs.image_of_le hf
state_before: α : Type u_2
ι : Type u_1
ι' : Type ?u.1728
inst✝² : DecidableEq ι
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
hs : PairwiseDisjoint (↑s) f
g : ι → ι
hf : ∀ (a : ι), f (g a) ≤ f a
⊢ PairwiseDisjoint (g '' ↑s) f
Theorem: YoungDiagram.exists_not_mem_col
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: convert μ.transpose.exists_not_mem_row j using 1
state_before: μ : YoungDiagram
j : ℕ
⊢ ∃ i, ¬(i, j) ∈ μ.cells

tactic: simp
state_before: case h.e'_2
μ : YoungDiagram
j : ℕ
⊢ (fun i => ¬(i, j) ∈ μ.cells) = fun j_1 => ¬(j, j_1) ∈ transpose μ
Theorem: Filter.Tendsto.atBot_add
File: Mathlib/Topology/Order/Basic.lean

tactic: conv in _ + _ => rw [add_comm]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x + g x) l atBot

tactic: exact hg.add_atBot hf
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : OrderTopology α
l : Filter β
f g : β → α
C : α
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => g x + f x) l atBot
Theorem: LinearPMap.domRestrict_le
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: simp
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.448336
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
S : Submodule R E
⊢ (domRestrict f S).domain ≤ f.domain
Theorem: Submodule.exists_lieSubmodule_coe_eq_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: constructor
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∃ N, ↑N = p) ↔ ∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p

tactic: rintro ⟨N, rfl⟩ _ _
state_before: case mp
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∃ N, ↑N = p) → ∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p

tactic: exact N.lie_mem
state_before: case mp.intro
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N : LieSubmodule R L M
x✝ : L
m✝ : M
⊢ m✝ ∈ ↑N → ⁅x✝, m✝⁆ ∈ ↑N

tactic: intro h
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
⊢ (∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p) → ∃ N, ↑N = p

tactic: use { p with lie_mem := @h }
state_before: case mpr
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
p : Submodule R M
h : ∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p
⊢ ∃ N, ↑N = p
Theorem: Localization.mulEquivOfQuotient_monoidOf
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: simp
state_before: M : Type u_2
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_1
inst✝¹ : CommMonoid N
P : Type ?u.3281425
inst✝ : CommMonoid P
f : Submonoid.LocalizationMap S N
x : M
⊢ ↑(mulEquivOfQuotient f) (↑(Submonoid.LocalizationMap.toMap (monoidOf S)) x) = ↑(Submonoid.LocalizationMap.toMap f) x
Theorem: UniformOnFun.hasBasis_uniformity_of_basis_aux₁
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp_rw [UniformOnFun.gen_eq_preimage_restrict, uniformity_comap]
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.59454
ι : Type u_2
s✝ s' : Set α
x : α
p✝ : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
p : ι → Prop
s : ι → Set (β × β)
hb : HasBasis (𝓤 β) p s
S : Set α
⊢ HasBasis (𝓤 (α →ᵤ[𝔖] β)) p fun i => UniformOnFun.gen 𝔖 S (s i)

tactic: exact (UniformFun.hasBasis_uniformity_of_basis S β hb).comap _
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.59454
ι : Type u_2
s✝ s' : Set α
x : α
p✝ : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
p : ι → Prop
s : ι → Set (β × β)
hb : HasBasis (𝓤 β) p s
S : Set α
⊢ HasBasis (comap (Prod.map (restrict S) (restrict S)) (𝓤 (↑S → β))) p fun i =>
    Prod.map (restrict S ∘ ↑UniformFun.toFun) (restrict S ∘ ↑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β (s i)
Theorem: MvPolynomial.constantCoeff_comp_map
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: ext <;> simp
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f✝ f : R →+* S₁
⊢ RingHom.comp constantCoeff (map f) = RingHom.comp f constantCoeff
Theorem: CategoryTheory.Adjunction.rightAdjointUniq_trans_app
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: apply Quiver.Hom.op_inj
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' G'' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
adj3 : F ⊣ G''
x : D
⊢ (rightAdjointUniq adj1 adj2).hom.app x ≫ (rightAdjointUniq adj2 adj3).hom.app x =
    (rightAdjointUniq adj1 adj3).hom.app x

tactic: dsimp [rightAdjointUniq]
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' G'' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
adj3 : F ⊣ G''
x : D
⊢ ((rightAdjointUniq adj1 adj2).hom.app x ≫ (rightAdjointUniq adj2 adj3).hom.app x).op =
    ((rightAdjointUniq adj1 adj3).hom.app x).op

tactic: simp
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' G'' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
adj3 : F ⊣ G''
x : D
⊢ (leftAdjointUniq (opAdjointOpOfAdjoint G'' F adj3) (opAdjointOpOfAdjoint G' F adj2)).hom.app x.op ≫
      (leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op =
    (leftAdjointUniq (opAdjointOpOfAdjoint G'' F adj3) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op
Theorem: Ioc_ofDual
File: Mathlib/Order/LocallyFinite.lean

tactic: refine' Eq.trans _ map_refl.symm
state_before: α : Type u_1
β : Type ?u.115387
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
⊢ Ioc (↑ofDual a) (↑ofDual b) = map (Equiv.toEmbedding ofDual) (Ico b a)

tactic: ext c
state_before: α : Type u_1
β : Type ?u.115387
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
⊢ Ioc (↑ofDual a) (↑ofDual b) = Ico b a

tactic: rw [mem_Ioc, mem_Ico (α := αᵒᵈ)]
state_before: case a
α : Type u_1
β : Type ?u.115387
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
c : (fun x => α) a
⊢ c ∈ Ioc (↑ofDual a) (↑ofDual b) ↔ c ∈ Ico b a

tactic: exact and_comm
state_before: case a
α : Type u_1
β : Type ?u.115387
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a✝ b✝ : α
a b : αᵒᵈ
c : (fun x => α) a
⊢ ↑ofDual a < c ∧ c ≤ ↑ofDual b ↔ b ≤ c ∧ c < a
Theorem: Matrix.det_permutation
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← Matrix.mul_one (σ.toPEquiv.toMatrix : Matrix n n R), PEquiv.toPEquiv_mul_matrix,
  det_permute, det_one, mul_one]
state_before: m : Type ?u.1185437
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
σ : Perm n
⊢ det (PEquiv.toMatrix (toPEquiv σ)) = ↑↑(↑sign σ)
Theorem: List.iota_eq_reverse_range'
File: Std/Data/List/Lemmas.lean

tactic: simp [iota, range'_concat, iota_eq_reverse_range' n, reverse_append, Nat.add_comm]
state_before: n : Nat
⊢ iota (n + 1) = reverse (range' 1 (n + 1))
Theorem: Finpartition.bot_isEquipartition
File: Mathlib/Order/Partition/Equipartition.lean

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
⊢ ∀ (a : Finset α), a ∈ ↑⊥.parts → Finset.card a = 1 ∨ Finset.card a = 1 + 1
Theorem: affineSegment_eq_segment
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [segment_eq_image_lineMap, affineSegment]
state_before: R : Type u_2
V : Type u_1
V' : Type ?u.5184
P : Type ?u.5187
P' : Type ?u.5190
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : V
⊢ affineSegment R x y = segment R x y
Theorem: MeasureTheory.OuterMeasure.map_sup
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp only [map_apply, sup_apply]
state_before: α : Type u_2
β✝ : Type ?u.78827
R : Type ?u.78830
R' : Type ?u.78833
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
β : Type u_1
f : α → β
m m' : OuterMeasure α
s : Set β
⊢ ↑(↑(map f) (m ⊔ m')) s = ↑(↑(map f) m ⊔ ↑(map f) m') s
Theorem: T_lt_one
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: have h := (div_lt_one (deriv_sq_norm_pos hnorm)).2 hnorm
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ T_gen p F a < 1

tactic: rw [T_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 < 1
⊢ T_gen p F a < 1

tactic: exact h
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
h : ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 < 1
⊢ ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 < 1
Theorem: singleton_div_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [singleton_div_ball, div_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / ball 1 δ = ball x δ
Theorem: List.mem_destutter'
File: Mathlib/Data/List/Destutter.lean

tactic: induction' l with b l hl
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b a : α
⊢ a ∈ destutter' R a l

tactic: rw [destutter']
state_before: case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ a b : α
l : List α
hl : a ∈ destutter' R a l
⊢ a ∈ destutter' R a (b :: l)

tactic: split_ifs
state_before: case cons
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ a b : α
l : List α
hl : a ∈ destutter' R a l
⊢ a ∈ if R a b then a :: destutter' R b l else destutter' R a l

tactic: simp
state_before: case nil
α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b a : α
⊢ a ∈ destutter' R a []

tactic: simp
state_before: case cons.inl
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ a b : α
l : List α
hl : a ∈ destutter' R a l
h✝ : R a b
⊢ a ∈ a :: destutter' R b l

tactic: assumption
state_before: case cons.inr
α : Type u_1
l✝ : List α
R : α → α → Prop
inst✝ : DecidableRel R
a✝ b✝ a b : α
l : List α
hl : a ∈ destutter' R a l
h✝ : ¬R a b
⊢ a ∈ destutter' R a l
Theorem: MonoidHom.map_neg_one
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [← map_pow, neg_one_sq, map_one]
state_before: β : Type ?u.293119
A : Type ?u.293122
G : Type ?u.293125
M : Type u_1
R : Type u_2
inst✝³ : Ring R
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f : R →* M
⊢ ↑f (-1) ^ Nat.succ 1 = 1
Theorem: LinearMap.tailings_zero
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp [tailings]
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.564691
M₆ : Type ?u.564694
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
⊢ tailings f i 0 = tailing f i 0
Theorem: SimpleGraph.Walk.end_mem_support
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ v ∈ support p
Theorem: CategoryTheory.Adjunction.leftAdjointUniq_trans
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
⊢ (leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom = (leftAdjointUniq adj1 adj3).hom

tactic: apply Quiver.Hom.op_inj
state_before: case w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x✝ : C
⊢ ((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x✝ = (leftAdjointUniq adj1 adj3).hom.app x✝

tactic: apply coyoneda.map_injective
state_before: case w.h.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x✝ : C
⊢ (((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x✝).op =
    ((leftAdjointUniq adj1 adj3).hom.app x✝).op

tactic: ext
state_before: case w.h.a.a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x✝ : C
⊢ coyoneda.map (((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x✝).op =
    coyoneda.map ((leftAdjointUniq adj1 adj3).hom.app x✝).op

tactic: funext
state_before: case w.h.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x✝¹ : C
x✝ : D
a✝ : (coyoneda.obj (F''.obj x✝¹).op).obj x✝
⊢ (coyoneda.map (((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x✝¹).op).app x✝ a✝ =
    (coyoneda.map ((leftAdjointUniq adj1 adj3).hom.app x✝¹).op).app x✝ a✝

tactic: simp [leftAdjointsCoyonedaEquiv, leftAdjointUniq]
state_before: case w.h.a.a.w.h.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F F' F'' : C ⥤ D
G : D ⥤ C
adj1 : F ⊣ G
adj2 : F' ⊣ G
adj3 : F'' ⊣ G
x✝¹ : C
x✝ : D
a✝ : (coyoneda.obj (F''.obj x✝¹).op).obj x✝
⊢ (coyoneda.map (((leftAdjointUniq adj1 adj2).hom ≫ (leftAdjointUniq adj2 adj3).hom).app x✝¹).op).app x✝ a✝ =
    (coyoneda.map ((leftAdjointUniq adj1 adj3).hom.app x✝¹).op).app x✝ a✝
Theorem: Complex.restrictScalars_one_smulRight
File: Mathlib/Analysis/Complex/Basic.lean

tactic: ext1 z
state_before: E : Type ?u.361704
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x : ℂ
⊢ restrictScalars ℝ (smulRight 1 x) = x • 1

tactic: dsimp
state_before: case h
E : Type ?u.361704
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ ↑(restrictScalars ℝ (smulRight 1 x)) z = ↑(x • 1) z

tactic: apply mul_comm
state_before: case h
E : Type ?u.361704
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
x z : ℂ
⊢ z * x = x * z
Theorem: EuclideanGeometry.inter_eq_singleton_orthogonalProjection
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [← orthogonalProjectionFn_eq]
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ ↑s ∩ ↑(mk' p (direction s)ᗮ) = {↑(↑(orthogonalProjection s) p)}

tactic: exact inter_eq_singleton_orthogonalProjectionFn p
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ ↑s ∩ ↑(mk' p (direction s)ᗮ) = {orthogonalProjectionFn s p}
Theorem: Submonoid.leftInvEquiv_symm_mul
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: convert S.mul_leftInvEquiv hS ((S.leftInvEquiv hS).symm x)
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ S }
⊢ ↑(↑(MulEquiv.symm (leftInvEquiv S hS)) x) * ↑x = 1

tactic: simp
state_before: case h.e'_2.h.e'_6.h.e'_3
M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
hS : S ≤ IsUnit.submonoid M
x : { x // x ∈ S }
⊢ x = ↑(leftInvEquiv S hS) (↑(MulEquiv.symm (leftInvEquiv S hS)) x)
Theorem: SemilatticeInf.ext
File: Mathlib/Order/Lattice.lean

tactic: have ss : A.toInf = B.toInf := by ext; apply SemilatticeInf.ext_inf H
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ A = B

tactic: cases A
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toInf = toInf
⊢ A = B

tactic: cases B
state_before: case mk
α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
B : SemilatticeInf α
toInf✝ : Inf α
toPartialOrder✝ : PartialOrder α
inf_le_left✝ : ∀ (a b : α), a ⊓ b ≤ a
inf_le_right✝ : ∀ (a b : α), a ⊓ b ≤ b
le_inf✝ : ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toInf = toInf
⊢ mk inf_le_left✝ inf_le_right✝ le_inf✝ = B

tactic: cases PartialOrder.ext H
state_before: case mk.mk
α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
toInf✝¹ : Inf α
toPartialOrder✝¹ : PartialOrder α
inf_le_left✝¹ : ∀ (a b : α), a ⊓ b ≤ a
inf_le_right✝¹ : ∀ (a b : α), a ⊓ b ≤ b
le_inf✝¹ : ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c
toInf✝ : Inf α
toPartialOrder✝ : PartialOrder α
inf_le_left✝ : ∀ (a b : α), a ⊓ b ≤ a
inf_le_right✝ : ∀ (a b : α), a ⊓ b ≤ b
le_inf✝ : ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toInf = toInf
⊢ mk inf_le_left✝¹ inf_le_right✝¹ le_inf✝¹ = mk inf_le_left✝ inf_le_right✝ le_inf✝

tactic: congr
state_before: case mk.mk.refl
α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
toInf✝¹ : Inf α
toPartialOrder✝ : PartialOrder α
inf_le_left✝¹ : ∀ (a b : α), a ⊓ b ≤ a
inf_le_right✝¹ : ∀ (a b : α), a ⊓ b ≤ b
le_inf✝¹ : ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c
toInf✝ : Inf α
inf_le_left✝ : ∀ (a b : α), a ⊓ b ≤ a
inf_le_right✝ : ∀ (a b : α), a ⊓ b ≤ b
le_inf✝ : ∀ (a b c : α), a ≤ b → a ≤ c → a ≤ b ⊓ c
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
ss : toInf = toInf
⊢ mk inf_le_left✝¹ inf_le_right✝¹ le_inf✝¹ = mk inf_le_left✝ inf_le_right✝ le_inf✝

tactic: ext
state_before: α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
⊢ toInf = toInf

tactic: apply SemilatticeInf.ext_inf H
state_before: case inf.h.h
α✝ : Type u
β : Type v
inst✝ : SemilatticeInf α✝
a b c d : α✝
α : Type u_1
A B : SemilatticeInf α
H : ∀ (x y : α), x ≤ y ↔ x ≤ y
x✝¹ x✝ : α
⊢ x✝¹ ⊓ x✝ = x✝¹ ⊓ x✝