tasksource/leandojo huggingface dataset:
Theorem: CompositionSeries.ofList_toList
File: Mathlib/Order/JordanHolder.lean

tactic: refine' ext_fun _ _
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s)) = s

tactic: rw [length_ofList, length_toList, Nat.succ_sub_one]
state_before: case refine'_1
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))).length = s.length

tactic: rintro ⟨i, hi⟩
state_before: case refine'_2
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ ∀ (i : Fin ((ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))).length + 1)),
    series (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))) i =
      series s
        (↑(Fin.cast
              (_ :
                Nat.succ (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))).length =
                  Nat.succ s.length))
          i)

tactic: simp [ofList, toList, -List.ofFn_succ]
state_before: case refine'_2.mk
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : ℕ
hi : i < (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))).length + 1
⊢ series (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))) { val := i, isLt := hi } =
    series s
      (↑(Fin.cast
            (_ :
              Nat.succ (ofList (toList s) (_ : toList s ≠ []) (_ : List.Chain' IsMaximal (toList s))).length =
                Nat.succ s.length))
        { val := i, isLt := hi })
Theorem: Subadditive.tendsto_lim
File: Mathlib/Analysis/Subadditive.lean

tactic: refine' tendsto_order.2 ⟨fun l hl => _, fun L hL => _⟩
state_before: u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
⊢ Tendsto (fun n => u n / ↑n) atTop (𝓝 (Subadditive.lim h))

tactic: refine' eventually_atTop.2
  ⟨1, fun n hn => hl.trans_le (h.lim_le_div hbdd (zero_lt_one.trans_le hn).ne')⟩
state_before: case refine'_1
u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
l : ℝ
hl : l < Subadditive.lim h
⊢ ∀ᶠ (b : ℕ) in atTop, l < u b / ↑b

tactic: obtain ⟨n, npos, hn⟩ : ∃ n : ℕ, 0 < n ∧ u n / n < L := by
  rw [Subadditive.lim] at hL
  rcases exists_lt_of_csInf_lt (by simp) hL with ⟨x, hx, xL⟩
  rcases (mem_image _ _ _).1 hx with ⟨n, hn, rfl⟩
  exact ⟨n, zero_lt_one.trans_le hn, xL⟩
state_before: case refine'_2
u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > Subadditive.lim h
⊢ ∀ᶠ (b : ℕ) in atTop, u b / ↑b < L

tactic: exact h.eventually_div_lt_of_div_lt npos.ne' hn
state_before: case refine'_2.intro.intro
u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > Subadditive.lim h
n : ℕ
npos : 0 < n
hn : u n / ↑n < L
⊢ ∀ᶠ (b : ℕ) in atTop, u b / ↑b < L

tactic: rw [Subadditive.lim] at hL
state_before: u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > Subadditive.lim h
⊢ ∃ n, 0 < n ∧ u n / ↑n < L

tactic: rcases exists_lt_of_csInf_lt (by simp) hL with ⟨x, hx, xL⟩
state_before: u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > sInf ((fun n => u n / ↑n) '' Ici 1)
⊢ ∃ n, 0 < n ∧ u n / ↑n < L

tactic: rcases (mem_image _ _ _).1 hx with ⟨n, hn, rfl⟩
state_before: case intro.intro
u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > sInf ((fun n => u n / ↑n) '' Ici 1)
x : ℝ
hx : x ∈ (fun n => u n / ↑n) '' Ici 1
xL : x < L
⊢ ∃ n, 0 < n ∧ u n / ↑n < L

tactic: exact ⟨n, zero_lt_one.trans_le hn, xL⟩
state_before: case intro.intro.intro.intro
u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > sInf ((fun n => u n / ↑n) '' Ici 1)
n : ℕ
hn : n ∈ Ici 1
hx : u n / ↑n ∈ (fun n => u n / ↑n) '' Ici 1
xL : u n / ↑n < L
⊢ ∃ n, 0 < n ∧ u n / ↑n < L

tactic: simp
state_before: u : ℕ → ℝ
h : Subadditive u
hbdd : BddBelow (range fun n => u n / ↑n)
L : ℝ
hL : L > sInf ((fun n => u n / ↑n) '' Ici 1)
⊢ Set.Nonempty ((fun n => u n / ↑n) '' Ici 1)
Theorem: Basis.singleton_repr
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.singleton, Unique.eq_default i]
state_before: ι✝ : Type ?u.612908
ι' : Type ?u.612911
R✝ : Type ?u.612914
R₂ : Type ?u.612917
K : Type ?u.612920
M : Type ?u.612923
M' : Type ?u.612926
M'' : Type ?u.612929
V : Type u
V' : Type ?u.612934
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
ι : Type u_1
R : Type u_2
inst✝¹ : Unique ι
inst✝ : Semiring R
x : R
i : ι
⊢ ↑(↑(Basis.singleton ι R).repr x) i = x
Theorem: TensorAlgebra.ringQuot_mkAlgHom_freeAlgebra_ι_eq_ι
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: rw [ι]
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m) = ↑(ι R) m

tactic: rfl
state_before: R : Type u_1
inst✝² : CommSemiring R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m) =
    ↑{
          toAddHom :=
            { toFun := fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m),
              map_add' :=
                (_ :
                  ∀ (x y : M),
                    (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) (x + y) =
                      (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) x +
                        (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) y) },
          map_smul' :=
            (_ :
              ∀ (r : R) (x : M),
                AddHom.toFun
                    { toFun := fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m),
                      map_add' :=
                        (_ :
                          ∀ (x y : M),
                            (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) (x + y) =
                              (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) x +
                                (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) y) }
                    (r • x) =
                  ↑(RingHom.id R) r •
                    AddHom.toFun
                      { toFun := fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m),
                        map_add' :=
                          (_ :
                            ∀ (x y : M),
                              (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) (x + y) =
                                (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) x +
                                  (fun m => ↑(RingQuot.mkAlgHom R (Rel R M)) (FreeAlgebra.ι R m)) y) }
                      x) }
      m
Theorem: UniformOnFun.postcomp_uniformInducing
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: constructor
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : UniformInducing f
⊢ UniformInducing (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖))

tactic: replace hf : (𝓤 β).comap (Prod.map f f) = _ := hf.comap_uniformity
state_before: case comap_uniformity
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : UniformInducing f
⊢ comap
      (fun x =>
        ((↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)) x.fst,
          (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)) x.snd))
      (𝓤 (α →ᵤ[𝔖] β)) =
    𝓤 (α →ᵤ[𝔖] γ)

tactic: rw [← uniformity_comap] at hf⊢
state_before: case comap_uniformity
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : comap (Prod.map f f) (𝓤 β) = 𝓤 γ
⊢ comap
      (Prod.map (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖))
        (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)))
      (𝓤 (α →ᵤ[𝔖] β)) =
    𝓤 (α →ᵤ[𝔖] γ)

tactic: congr
state_before: case comap_uniformity
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : 𝓤 γ = 𝓤 γ
⊢ 𝓤 (α →ᵤ[𝔖] γ) = 𝓤 (α →ᵤ[𝔖] γ)

tactic: rw [← uniformSpace_eq hf, UniformOnFun.comap_eq]
state_before: case comap_uniformity.h.e_2.h
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : 𝓤 γ = 𝓤 γ
⊢ UniformSpace.comap (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)) (uniformSpace α β 𝔖) = uniformSpace α γ 𝔖

tactic: rfl
state_before: case comap_uniformity.h.e_2.h
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.78533
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : 𝓤 γ = 𝓤 γ
⊢ UniformSpace.comap (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)) (uniformSpace α β 𝔖) =
    UniformSpace.comap ((fun x x_1 => x ∘ x_1) f) (uniformSpace α β 𝔖)
Theorem: Equiv.Perm.finRotate_bit1_mem_alternatingGroup
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

tactic: rw [mem_alternatingGroup, bit1, sign_finRotate, pow_bit0', Int.units_mul_self, one_pow]
state_before: α : Type ?u.27282
inst✝¹ : Fintype α
inst✝ : DecidableEq α
n : ℕ
⊢ finRotate (bit1 n) ∈ alternatingGroup (Fin (bit1 n))
Theorem: FiniteDimensional.finrank_mul_finrank'
File: Mathlib/FieldTheory/Tower.lean

tactic: letI := nontrivial_of_invariantBasisNumber F
state_before: F : Type u
K : Type v
A : Type w
inst✝¹³ : CommRing F
inst✝¹² : Ring K
inst✝¹¹ : AddCommGroup A
inst✝¹⁰ : Algebra F K
inst✝⁹ : Module K A
inst✝⁸ : Module F A
inst✝⁷ : IsScalarTower F K A
inst✝⁶ : StrongRankCondition F
inst✝⁵ : StrongRankCondition K
inst✝⁴ : Module.Free F K
inst✝³ : Module.Free K A
inst✝² : Nontrivial K
inst✝¹ : Module.Finite F K
inst✝ : Module.Finite K A
⊢ finrank F K * finrank K A = finrank F A

tactic: let b := Module.Free.chooseBasis F K
state_before: F : Type u
K : Type v
A : Type w
inst✝¹³ : CommRing F
inst✝¹² : Ring K
inst✝¹¹ : AddCommGroup A
inst✝¹⁰ : Algebra F K
inst✝⁹ : Module K A
inst✝⁸ : Module F A
inst✝⁷ : IsScalarTower F K A
inst✝⁶ : StrongRankCondition F
inst✝⁵ : StrongRankCondition K
inst✝⁴ : Module.Free F K
inst✝³ : Module.Free K A
inst✝² : Nontrivial K
inst✝¹ : Module.Finite F K
inst✝ : Module.Finite K A
this : Nontrivial F := nontrivial_of_invariantBasisNumber F
⊢ finrank F K * finrank K A = finrank F A

tactic: let c := Module.Free.chooseBasis K A
state_before: F : Type u
K : Type v
A : Type w
inst✝¹³ : CommRing F
inst✝¹² : Ring K
inst✝¹¹ : AddCommGroup A
inst✝¹⁰ : Algebra F K
inst✝⁹ : Module K A
inst✝⁸ : Module F A
inst✝⁷ : IsScalarTower F K A
inst✝⁶ : StrongRankCondition F
inst✝⁵ : StrongRankCondition K
inst✝⁴ : Module.Free F K
inst✝³ : Module.Free K A
inst✝² : Nontrivial K
inst✝¹ : Module.Finite F K
inst✝ : Module.Finite K A
this : Nontrivial F := nontrivial_of_invariantBasisNumber F
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
⊢ finrank F K * finrank K A = finrank F A

tactic: rw [finrank_eq_card_basis b, finrank_eq_card_basis c, finrank_eq_card_basis (b.smul c),
  Fintype.card_prod]
state_before: F : Type u
K : Type v
A : Type w
inst✝¹³ : CommRing F
inst✝¹² : Ring K
inst✝¹¹ : AddCommGroup A
inst✝¹⁰ : Algebra F K
inst✝⁹ : Module K A
inst✝⁸ : Module F A
inst✝⁷ : IsScalarTower F K A
inst✝⁶ : StrongRankCondition F
inst✝⁵ : StrongRankCondition K
inst✝⁴ : Module.Free F K
inst✝³ : Module.Free K A
inst✝² : Nontrivial K
inst✝¹ : Module.Finite F K
inst✝ : Module.Finite K A
this : Nontrivial F := nontrivial_of_invariantBasisNumber F
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
c : Basis (Module.Free.ChooseBasisIndex K A) K A := Module.Free.chooseBasis K A
⊢ finrank F K * finrank K A = finrank F A
Theorem: Algebra.TensorProduct.map_comp_includeRight
File: Mathlib/RingTheory/TensorProduct.lean

tactic: simp
state_before: R : Type u
inst✝⁸ : CommSemiring R
A : Type v₁
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
B : Type v₂
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R B
C : Type v₃
inst✝³ : Semiring C
inst✝² : Algebra R C
D : Type v₄
inst✝¹ : Semiring D
inst✝ : Algebra R D
f : A →ₐ[R] B
g : C →ₐ[R] D
⊢ ∀ (x : C), ↑(AlgHom.comp (map f g) includeRight) x = ↑(AlgHom.comp includeRight g) x
Theorem: Stream'.Seq.map_append
File: Mathlib/Data/Seq/Seq.lean

tactic: apply
  eq_of_bisim (fun s1 s2 => ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)) _
    ⟨s, t, rfl, rfl⟩
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s t : Seq α
⊢ map f (append s t) = append (map f s) (map f t)

tactic: intro s1 s2 h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s t : Seq α
⊢ IsBisimulation fun s1 s2 => ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)

tactic: apply recOn s <;> simp
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s✝ t✝ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s t : Seq α
⊢ BisimO (fun s1 s2 => ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)) (destruct (map f (append s t)))
    (destruct (append (map f s) (map f t)))

tactic: apply recOn t <;> simp
state_before: case h1
α : Type u
β : Type v
γ : Type w
f : α → β
s✝ t✝ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s t : Seq α
⊢ match destruct (map f t), destruct (map f t) with
  | none, none => True
  | some (a, s), some (a', s') => a = a' ∧ ∃ s_1 t, s = map f (append s_1 t) ∧ s' = append (map f s_1) (map f t)
  | x, x_1 => False

tactic: intro _ t
state_before: case h1.h2
α : Type u
β : Type v
γ : Type w
f : α → β
s✝ t✝ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s t : Seq α
⊢ α → ∀ (s : Seq α), ∃ s_1 t, map f s = map f (append s_1 t) ∧ map f s = append (map f s_1) (map f t)

tactic: refine' ⟨nil, t, _, _⟩ <;> simp
state_before: case h1.h2
α : Type u
β : Type v
γ : Type w
f : α → β
s✝ t✝¹ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s t✝ : Seq α
x✝ : α
t : Seq α
⊢ ∃ s t_1, map f t = map f (append s t_1) ∧ map f t = append (map f s) (map f t_1)

tactic: intro _ s
state_before: case h2
α : Type u
β : Type v
γ : Type w
f : α → β
s✝ t✝ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s t : Seq α
⊢ α →
    ∀ (s : Seq α),
      ∃ s_1 t_1,
        map f (append s t) = map f (append s_1 t_1) ∧ append (map f s) (map f t) = append (map f s_1) (map f t_1)

tactic: refine' ⟨s, t, rfl, rfl⟩
state_before: case h2
α : Type u
β : Type v
γ : Type w
f : α → β
s✝¹ t✝ : Seq α
s1 s2 : Seq β
h : ∃ s t, s1 = map f (append s t) ∧ s2 = append (map f s) (map f t)
s✝ t : Seq α
x✝ : α
s : Seq α
⊢ ∃ s_1 t_1, map f (append s t) = map f (append s_1 t_1) ∧ append (map f s) (map f t) = append (map f s_1) (map f t_1)
Theorem: List.nthLe_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp [nthLe]
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin n
⊢ nthLe (ofFn f) ↑i (_ : ↑i < length (ofFn f)) = f i
Theorem: EuclideanGeometry.reflection_symm
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: ext
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 }
⊢ AffineIsometryEquiv.symm (reflection s) = reflection s

tactic: rw [← (reflection s).injective.eq_iff]
state_before: case h
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 }
x✝ : P
⊢ ↑(AffineIsometryEquiv.symm (reflection s)) x✝ = ↑(reflection s) x✝

tactic: simp
state_before: case h
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 }
x✝ : P
⊢ ↑(reflection s) (↑(AffineIsometryEquiv.symm (reflection s)) x✝) = ↑(reflection s) (↑(reflection s) x✝)
Theorem: CategoryTheory.Limits.PreservesPushout.inr_iso_hom
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: delta PreservesPushout.iso
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ pushout.inr ≫ (iso G f g).hom = G.map pushout.inr

tactic: simp
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ pushout.inr ≫
      (IsColimit.coconePointUniqueUpToIso (colimit.isColimit (span (G.map f) (G.map g)))
          (isColimitOfHasPushoutOfPreservesColimit G f g)).hom =
    G.map pushout.inr
Theorem: LinearEquiv.snd_comp_prodComm
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext <;> simp
state_before: N : Type u_1
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.405020
M₆ : Type ?u.405023
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid N
inst✝¹ : Module R M
inst✝ : Module R N
⊢ LinearMap.comp (LinearMap.snd R N M) ↑(prodComm R M N) = LinearMap.fst R M N
Theorem: Nat.map_div_left_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: apply Finset.map_injective (Equiv.prodComm _ _).toEmbedding
state_before: n : ℕ
⊢ map
      { toFun := fun d => (n / d, d),
        inj' :=
          (_ :
            ∀ (p₁ p₂ : ℕ),
              (fun d => (n / d, d)) p₁ = (fun d => (n / d, d)) p₂ →
                ((fun d => (n / d, d)) p₁).snd = ((fun d => (n / d, d)) p₂).snd) }
      (divisors n) =
    divisorsAntidiagonal n

tactic: rw [map_swap_divisorsAntidiagonal, ← map_div_right_divisors, Finset.map_map]
state_before: case a
n : ℕ
⊢ map (Equiv.toEmbedding (Equiv.prodComm ℕ ℕ))
      (map
        { toFun := fun d => (n / d, d),
          inj' :=
            (_ :
              ∀ (p₁ p₂ : ℕ),
                (fun d => (n / d, d)) p₁ = (fun d => (n / d, d)) p₂ →
                  ((fun d => (n / d, d)) p₁).snd = ((fun d => (n / d, d)) p₂).snd) }
        (divisors n)) =
    map (Equiv.toEmbedding (Equiv.prodComm ℕ ℕ)) (divisorsAntidiagonal n)

tactic: rfl
state_before: case a
n : ℕ
⊢ map
      (Function.Embedding.trans
        { toFun := fun d => (n / d, d),
          inj' :=
            (_ :
              ∀ (p₁ p₂ : ℕ),
                (fun d => (n / d, d)) p₁ = (fun d => (n / d, d)) p₂ →
                  ((fun d => (n / d, d)) p₁).snd = ((fun d => (n / d, d)) p₂).snd) }
        (Equiv.toEmbedding (Equiv.prodComm ℕ ℕ)))
      (divisors n) =
    map
      { toFun := fun d => (d, n / d),
        inj' :=
          (_ :
            ∀ (p₁ p₂ : ℕ),
              (fun d => (d, n / d)) p₁ = (fun d => (d, n / d)) p₂ →
                ((fun d => (d, n / d)) p₁).fst = ((fun d => (d, n / d)) p₂).fst) }
      (divisors n)
Theorem: Real.Angle.abs_toReal_eq_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [abs_eq (div_nonneg Real.pi_pos.le two_pos.le), ← neg_div, toReal_eq_pi_div_two_iff,
  toReal_eq_neg_pi_div_two_iff]
state_before: θ : Angle
⊢ abs (toReal θ) = π / 2 ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
Theorem: TotallyBounded.image
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: simp [image_subset_iff]
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
hs : TotallyBounded s
hf : UniformContinuous f
t : Set (β × β)
ht : t ∈ 𝓤 β
this : {p | (f p.fst, f p.snd) ∈ t} ∈ 𝓤 α
c : Set α
hfc : Set.Finite c
hct : s ⊆ ⋃ (y : α) (_ : y ∈ c), {x | (x, y) ∈ {p | (f p.fst, f p.snd) ∈ t}}
⊢ f '' s ⊆ ⋃ (y : β) (_ : y ∈ f '' c), {x | (x, y) ∈ t}

tactic: simp [subset_def] at hct
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
hs : TotallyBounded s
hf : UniformContinuous f
t : Set (β × β)
ht : t ∈ 𝓤 β
this : {p | (f p.fst, f p.snd) ∈ t} ∈ 𝓤 α
c : Set α
hfc : Set.Finite c
hct : s ⊆ ⋃ (y : α) (_ : y ∈ c), {x | (x, y) ∈ {p | (f p.fst, f p.snd) ∈ t}}
⊢ s ⊆ ⋃ (i : α) (_ : i ∈ c), {a | (f a, f i) ∈ t}

tactic: intro x hx
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
hs : TotallyBounded s
hf : UniformContinuous f
t : Set (β × β)
ht : t ∈ 𝓤 β
this : {p | (f p.fst, f p.snd) ∈ t} ∈ 𝓤 α
c : Set α
hfc : Set.Finite c
hct : ∀ (x : α), x ∈ s → ∃ i, i ∈ c ∧ (f x, f i) ∈ t
⊢ s ⊆ ⋃ (i : α) (_ : i ∈ c), {a | (f a, f i) ∈ t}

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
hs : TotallyBounded s
hf : UniformContinuous f
t : Set (β × β)
ht : t ∈ 𝓤 β
this : {p | (f p.fst, f p.snd) ∈ t} ∈ 𝓤 α
c : Set α
hfc : Set.Finite c
hct : ∀ (x : α), x ∈ s → ∃ i, i ∈ c ∧ (f x, f i) ∈ t
x : α
hx : x ∈ s
⊢ x ∈ ⋃ (i : α) (_ : i ∈ c), {a | (f a, f i) ∈ t}

tactic: exact hct x hx
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
f : α → β
s : Set α
hs : TotallyBounded s
hf : UniformContinuous f
t : Set (β × β)
ht : t ∈ 𝓤 β
this : {p | (f p.fst, f p.snd) ∈ t} ∈ 𝓤 α
c : Set α
hfc : Set.Finite c
hct : ∀ (x : α), x ∈ s → ∃ i, i ∈ c ∧ (f x, f i) ∈ t
x : α
hx : x ∈ s
⊢ ∃ i, i ∈ c ∧ (f x, f i) ∈ t
Theorem: Matrix.mul_adjugate_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: erw [← smul_eq_mul, adjugate, of_apply, ← Pi.smul_apply, ← LinearMap.map_smul, ← Pi.single_smul',
  smul_eq_mul, mul_one]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
i j k : n
⊢ A i k * adjugate A k j = ↑(cramer Aᵀ) (Pi.single k (A i k)) j
Theorem: Set.projIcc_of_mem
File: Mathlib/Data/Set/Intervals/ProjIcc.lean

tactic: simp [projIcc, hx.1, hx.2]
state_before: α : Type u_1
β : Type ?u.7809
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x : α
hx : x ∈ Icc a b
⊢ projIcc a b h x = { val := x, property := hx }
Theorem: Set.preimage_add_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [add_comm] using preimage_const_add_uIcc a b c
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => x + a) ⁻¹' [[b, c]] = [[b - a, c - a]]
Theorem: EuclideanDomain.gcd_eq_gcd_ab
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: have :=
  @xgcdAux_P _ _ _ a b a b 1 0 0 1 (by dsimp [P]; rw [mul_one, mul_zero, add_zero])
    (by dsimp [P]; rw [mul_one, mul_zero, zero_add])
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ gcd a b = a * gcdA a b + b * gcdB a b

tactic: rwa [xgcdAux_val, xgcd_val] at this
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
this : EuclideanDomain.P a b (xgcdAux a 1 0 b 0 1)
⊢ gcd a b = a * gcdA a b + b * gcdB a b

tactic: dsimp [P]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ EuclideanDomain.P a b (a, 1, 0)

tactic: rw [mul_one, mul_zero, add_zero]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ a = a * 1 + b * 0

tactic: dsimp [P]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ EuclideanDomain.P a b (b, 0, 1)

tactic: rw [mul_one, mul_zero, zero_add]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ b = a * 0 + b * 1