Discussão:Cadastro de Pessoas Físicas

Título

Talvez devêssemos ter um artigo Cartão de CPF (ou CPF (documento), como estava antes), falando só sobre o documento. Afinal, o Cadastro e o cartão são coisas diferentes mesmo, apesar da minha tentativa em falar sobre os dois neste artigo. Não sei, estou em dúvida. --E2m 12:14, 22 Jan 2005 (UTC)

Minha opinião: os dois assuntos não são tão abrangentes assim, e estão diretamente relacionados. Assim, se for o caso, podemos fazer duas sub-seções, uma para o cadastro, e outra para o cartão.... Mas como está, me parece razoável (pelo menos a mim). --Andre v 15:23, 22 Jan 2005 (UTC)

O melhor estilo não é colocar a sigla antes do significado da mesma. --E2m 15:19, 22 Jan 2005 (UTC)

Sobre a sigla depois do nome: tudo bem, embora eu (pessoalmente) prefira o estilo "nome depois da sigla". Mas se é pra padronizar... ok! Abraços, Andre v 15:23, 22 Jan 2005 (UTC)

Eu tirei os parêntes de "(ou CPF)" para ficar mais explícito que a sigla é muito utilizada. Se quiser, coloque-os novamente. Também tirei o artigo da definição, pois não se usa. Abraços! --E2m 15:38, 22 Jan 2005 (UTC)

Quando se emite um cheque sem fundos o CPF não é cancelado, pois essa ação nada tem a ver com a Receita Federal, o CPF nesse caso é incluído no CCF, Cadastro de Emitentes de Cheques sem fundos do Banco Central, e no SERASA, mas continuará regular perante a Receita, vide www.receita.fazenda.gov.br, www.bcb.gov.br

Concordo que deva fundir os dois artigos, falam sobre o mesmo assunto e um complementa o outro. —o comentário precedente não foi assinado por 200.189.112.20 (discussão • contrib.) J.P.Chagas 18h06min de 21 de Novembro de 2007 (UTC)

Validação

A validação em pascal estava bem errada, com apenas metade da validação do primeiro dígito e apenas a outra metade do segundo dígito. De qualquer forma, coloquei um exemplo que eu escrevi em Object Pascal, já que tive que criar pra usar, coloquei aqui.

Mas seria muito interessante se alguém colocasse uma versão mais livre de linguagem de programação, como muito bem feito no artigo sobre CNPJ. 189.72.110.235 (discussão) 13h06min de 23 de março de 2009 (UTC)

Concordo que o código de validação deveria ser numa versão livre de linguagem de programação, então estou revertendo para a versão original (que, aliás, eu mesmo fiz, como também fiz a do CNPJ), que posteriormente foi convertida para Pascal e Object Pascal. Kugland (discussão) 16h45min de 20 de abril de 2009 (UTC)

Embora a fórmula de validação seja matematicamente válida (mesmo eu não entendendo o porquê, explicações serão bem-vindas) ela destoa muito daquilo que é estabelecido na norma http://normas.receita.fazenda.gov.br/sijut2consulta/link.action?idAto=20139&visao=anotado o que pode causar confusão para leitores que consultam o verbete buscando entender como é feito o cálculo Flvcst (discussão) 20h22min de 11 de outubro de 2016 (UTC)

@Flvcst: O documento da receita orienta que o CPF utilize dois dígitos verificadores utilizando o módulo 11, e dá um exemplo de como efetuar o cálculo. O módulo 11 é um algoritmo difundido para cálculo de dígitos verificadores e aqui apenas está sendo apresentada uma versão mais apropriada para o cálculo simultâneo dos dois dígitos do CPF (sem a necessidade de dois loops). Aí ficamos em um empasse: colocamos a versão mais eficiente ou a mais redundante? É difícil responder. Por outro lado, acho que o que deveria ser questionado é se esse artigo deve ou não conter algoritmos. Me parece técnico demais para um artigo sobre um documento. --Diego Queiroz (discussão) 21h27min de 11 de outubro de 2016 (UTC)

Acredito que tanto a fórmula da norma, quanto a fórmula otimizada deveriam constar nessa página, pois ela serve de referência para quem precisar da informação. O texto é dividido em tópicos, quem não precisar de um tópico não precisa lê-lo. O link para a norma deveria constar nesta seção. E idealmente deveria conter algum link ou uma demonstração de que as duas fórmulas são realmente equivalentes. Marcelo.jimenez (discussão) 18h05min de 2 de janeiro de 2019 (UTC)

Não está escrito explicitamente, mas nas fórmulas, o valor de n é constante e igual a nove. Marcelo.jimenez (discussão) 18h05min de 2 de janeiro de 2019 (UTC)

Na fórmula otimizada, me parece que as expressões $\left(i{\text{ mod }}10\right)$ e $\left[\left(i+1\right){\text{ mod }}10\right]$ não são necessárias, pois como o valor de n é nove, o maior valor possível de i é oito no primeiro dígito verificador, e nove no segundo dígito verificador. Assim sendo, no cálculo do somatório sempre vale que $\left(i{\text{ mod }}10\right)=i$ e $\left[\left(i+1\right){\text{ mod }}10\right]=i+1$ e a operação "mod" é desnecessária nesta parte do algorítmo. Marcelo.jimenez (discussão) 18h05min de 2 de janeiro de 2019 (UTC)

Também, pode-se mostrar que $v_{2}$ não depende de $d_{8}$. Na norma isto fica óbvio, pois multiplicar por 11 em aritmética modulo 11 é o mesmo que multiplicar por zero. Na fórmula otimizada dá pra ver no caso de $v_{2}$ que quando $i=8$, existe uma multiplicação por zero. Este fato pode ser usado para fazer uma versão ligeiramente mais eficiente do algorítimo dito "otimizado". Marcelo.jimenez (discussão) 18h23min de 2 de janeiro de 2019 (UTC)

Código da validação em C# estranho

Estava a tentar fazer uma versão PL/SQL do código a partir da versão C#, quando reparei nesta linha de código:

(...) if( 1.ToString() == "1" ) (...)

Parei logo aqui. Além de ser uma forma de programação horrível, claramente, é o mesmo que "if ( true )".

O que me faz duvidar do resto do código, pelo menos C#.

RMP —comentário não assinado de 85.88.145.162 (discussão • contrib) 13h14min de 14 de dezembro de 2011‎ (UTC)

Verificação incompleta

Em alguns dos códigos (como em Delphi), após a soma ser realizada, é testado se (11-resto) é igual a 10 para, nesse caso, definir o dígito como 0. Mas no caso de (11-resto) ser igual a 11 (ou seja, resto = soma mod 11 = 0), o dígito também deve ser 0. Resumindo, se o resto for 0 ou 1, o dígito deve ser 0, mas só é testado o caso de ele ser 1. Ex.: O CPF aleatório que um programa que fiz gerou, 825.176.380-04. Para o primeiro dígito, a soma dá 253, e 253 mod 11 = 0. Esse CPF não seria considerado válido do jeito que está. Corrijam quem estiver errado, eu ou os códigos =). —comentário não assinado de 187.112.91.46 (discussão • contrib) 16h15min de 18 de junho de 2012‎ (UTC)

Remover fragmentos de códigos de validação

Estes fragmentos de código de validação deveriam ser removidos, ter estas instruções viola WP:MANUAL e WP:RDI. —comentário não assinado de Defrancos (discussão • contrib) 14h14min de 17 de julho de 2012‎ (UTC)

Tem razão. Vou mover os códigos-fonte para cá por enquanto, para o caso de alguém querer aproveitá-los. —capmo¦ompac— 19h21min de 2 de abril de 2014 (UTC)

Obs.: o trecho seguinte está "compactado" de modo a despoluir visualmente o contexto da página toda.

Delphi

function ValidarCPF(CPF: String): Boolean;
var vCPF, vDigito: String;
    DF1, DF2: Integer;
begin
  Result := False;

  vCPF := CPF;

  // Removendo caracteres especiais
  vCPF := StringReplace( vCPF, '.', '', [rfReplaceAll] );
  vCPF := StringReplace( vCPF, '-', '', [rfReplaceAll] );

  // Verificar tamanho dos dígitos do CPF e invalidar CPFs não permitidos
  if ( Length( vCPF ) <> 11 ) or ( vCPF = '11111111111' ) or
     ( vCPF = '22222222222' ) or ( vCPF = '33333333333' ) or
     ( vCPF = '44444444444' ) or ( vCPF = '55555555555' ) or
     ( vCPF = '66666666666' ) or ( vCPF = '77777777777' ) or
     ( vCPF = '88888888888' ) or ( vCPF = '99999999999' ) then
    Exit;

  // Armazena o número do CPF e o digito separados
  vDigito := Copy( vCPF, 10, 02 );
  vCPF    := Copy( vCPF, 01, 09 );

  // Somar e multiplicar os pesos do digito 1 para cada número
  DF1 :=       (StrToInt(vCPF[1])*10) + (StrToInt(vCPF[2])*09) + (StrToInt(vCPF[3])*08);
  DF1 := DF1 + (StrToInt(vCPF[4])*07) + (StrToInt(vCPF[5])*06) + (StrToInt(vCPF[6])*05);
  DF1 := DF1 + (StrToInt(vCPF[7])*04) + (StrToInt(vCPF[8])*03) + (StrToInt(vCPF[9])*02);

  // Cálculo da diferença de 11 com o resto de DF1
  DF1 := 11 - ( DF1 mod 11 );

  // Se o resultado anterior for igual a 10, o dígito 1 é 0, caso contrário,
  // o digito 1 é o próprio resultado.
  if DF1 >= 10 then DF1 := 0;

  // Somar e multiplicar os pesos do digito 2 em cada número
  DF2 :=       (StrToInt(vCPF[1])*11) + (StrToInt(vCPF[2])*10) + (StrToInt(vCPF[3])*09);
  DF2 := DF2 + (StrToInt(vCPF[4])*08) + (StrToInt(vCPF[5])*07) + (StrToInt(vCPF[6])*06);
  DF2 := DF2 + (StrToInt(vCPF[7])*05) + (StrToInt(vCPF[8])*04) + (StrToInt(vCPF[9])*03);

  // Somar o resultado do digito 2 com o dobro do digito 1
  DF2 := DF2 + (2 * DF1);

  // Cálculo da diferença de 11 com o resto de DF2
  DF2 := 11 - ( DF2 mod 11 );

  // Se o resultado anterior for igual a 10, o dígito 2 é 0, caso contrário,
  // o digito 2 é o próprio resultado.
  if DF2 >= 10 then DF2 := 0;

  // Retorna verdadeiro ou falso, caso o dígito informado coincida ou não com o calculado
  Result := vDigito = IntToStr(DF1) + IntToStr(DF2);
end;

C#

     public bool validateCPF(string cpf)
        {
            cpf = cpf.Replace("-", "").Replace(".", "").Replace(",", "").Replace(" ", "").Replace("_", "");
            string verification = cpf[9].ToString() + cpf[10].ToString();

            int firstVerificationDigit = 0;
            int secondVerificationDigit = 0;
            for (int i = 0; i < 9; ++i)
            {
                firstVerificationDigit += int.Parse("" + cpf[i].ToString()) * (10 - i);
                secondVerificationDigit += int.Parse("" + cpf[i].ToString()) * (11 - i);
            }

            firstVerificationDigit = 11 - (firstVerificationDigit % 11);
            firstVerificationDigit = firstVerificationDigit >= 10 ? 0 : firstVerificationDigit;
            secondVerificationDigit += 2 * firstVerificationDigit;
            secondVerificationDigit = 11 - (secondVerificationDigit % 11);
            secondVerificationDigit = secondVerificationDigit >= 10 ? 0 : secondVerificationDigit;
            if (firstVerificationDigit == int.Parse("" + verification[0].ToString()) && secondVerificationDigit == int.Parse(verification[1].ToString()))
            {
                return true;
            }

            return false;

        }

Java

    /**
     * Este metodo Valida o numero de um CPF usando a regra mod11
     * @param num_cpf Numero CPF
     * @param DV_cpf Digitos verificadores
     * @return true caso seja valido e false caso não;
     * @throws RuntimeException caso seja digitado mais de 9 numeros irá haver erro tem tempo de execução
     * @autor Denis Benjamim
     */
    public boolean verificaCPF(Integer num_cpf,Integer DV_cpf)throws RuntimeException{
        //Se o numer nao for igual a 9 ou o digito verificado igual a 2 return false
        if(num_cpf.toString().length()!=9 || DV_cpf.toString().length()!=2)
        {
            JOptionPane.showMessageDialog(null, "A quantidade de Digitos informada esta incorreta."
                                              ,"Informação do Sistema",JOptionPane.ERROR_MESSAGE);
            return false;
        }
        Integer soma=0;// soma do total inicia em 0
        Integer i=0;//Incrementa i a cada Volta e inicia em 0
        
        /*
         * Converte o valor Intero em String 
         * Converte a String em um array de caracters
         * Percorre o Array de Caracters 
         */        
        for(char at:num_cpf.toString().toCharArray()){
            //Multiplica i por At e adiciona o valor e soma com o valor dentro de soma
            soma+=i* Character.getNumericValue(at);
            //Incrementa i
            i++;
        }
       //Acrescenta  o primeiro digito do DV a soma para verificar o mod11
        soma+=i*Character.getNumericValue(DV_cpf.toString().charAt(0));
       
        //Se a divisao da soma por 11  tiver o resto igual a 10 resto será 0 se não resto será igual ao resto da divisao;        
        Integer resto11 = soma%11==10?0:soma%11;
        
        i=1;//I começa em 1 para calcula o primeiro digito verificado
        soma=0;// Soma é zerado para armazenar  a nova Soma
        /*
         * Converte o valor Intero em String 
         * Converte a String em um array de caracters
         * Percorre o Array de Caracters 
         */        
        for(char at:num_cpf.toString().toCharArray()){
            //Multiplica i por At e adiciona o valor e soma com o valor dentro de soma
            soma+=i* Character.getNumericValue(at);
            //Incrementa i
            i++;
        }
         //Se a divisao da soma por 11  tiver o resto igual a 10 resto será 0 se não resto será igual ao resto da divisao;        
        Integer resto10 = soma%11==10?0:soma%11;
         
        //Se o resto10 for igual ao primeiro digito do DV_cpfo e resto11 for igual ao ultimo digito do DV_cpf retorna true 
        if(resto10==Character.getNumericValue(DV_cpf.toString().charAt(0)) &&    
           resto11==Character.getNumericValue(DV_cpf.toString().charAt(1)))
            return true;
        
        return false;
    }

JavaScript

    function validarCpf(cpf){
        var digitsString = cpf.replace(/[^0-9]/g, '');
        var digits;
        var a,b,c,d,e,f,g,h,i,j,k;
        var dv1, dv2;
        var soma, resto;
        
        if (digitsString.length == 11){
            digits = digitsString.split('');
            a = parseInt(digits[ 0 ]);
            b = parseInt(digits[ 1 ]);
            c = parseInt(digits[ 2 ]);
            d = parseInt(digits[ 3 ]);
            e = parseInt(digits[ 4 ]);
            f = parseInt(digits[ 5 ]);
            g = parseInt(digits[ 6 ]);
            h = parseInt(digits[ 7 ]);
            i = parseInt(digits[ 8 ]);
            j = parseInt(digits[ 9 ]);
            k = parseInt(digits[ 10 ]);
            soma = a*10 + b*9 + c*8 + d*7 + e*6 + f*5 + g*4 + h*3 + i*2;
            resto = soma % 11;
            dv1 = (11 - resto < 10 ? 11 - resto : 0);
            soma = a*11 + b*10 + c*9 + d*8 + e*7 + f*6 + g*5 + h*4 + i*3 + dv1*2;
            resto = soma % 11;
            dv2 = (11 - resto < 10 ? 11 - resto : 0);
            return dv1 == j && dv2 == k;
        }
        return false;
    }

PHP

/**
 * Verifica se é um número de CPF válido.
 *
 * @param $cpf O número a ser verificado
 * @return boolean
 */
function validarCPF($cpf)
{
    // remove os caracteres não-numéricos
    $cpf = preg_replace('/\D/', '', $cpf);

    // verifica se a sequência tem 11 dígitos
    if (strlen($cpf) != 11)
        return false;

    // calcula o primeiro dígito verificador 
    $sum = 0;
    for ($i = 0; $i < 9; $i++) {
        $sum += $cpf[$i] * (10-$i);
    }
    $mod = $sum % 11;
    $digit = ($mod > 1) ? (11 - $mod) : 0;

    // verifica se o primeiro dígito verificador está correto
    if ($cpf[9] != $digit)
        return false;

    // calcula o segundo dígito verificador
    $sum = 0;
    for ($i = 0; $i < 10; $i++) {
        $sum += $cpf[$i] * (11-$i);
    }
    $mod = $sum % 11;
    $digit = ($mod > 1) ? (11 - $mod) : 0;

    // verifica se o segundo dígito verificador está correto
    if ($cpf[10] != $digit)
        return false;

    // Repetir 11 vezes o mesmo número não é permitido, pois não existem CPFs com esta formação numérica.
    if (str_repeat($cpf[0],11) == $cpf) {
        return false;
    }
    // está tudo certo
    return true;
}

PL/SQL

Nota: esta função replica o cálculo, mas para retornar os validadores. Fazer a validação será comparar o retorno desta função com os 2 últimos dígitos do número),

create or replace function ObterValidadores
(
  i_Numero in nvarchar2
)
return nvarchar2
is
  v_Digito1 number;
  v_Digito2 number;
begin

  -----------------------------------------------------------------------------
  -- Validacoes
  -----------------------------------------------------------------------------
  if ( i_Numero is null ) then
    return null;
  end if;

  if ( length( i_Numero ) not in ( 9, 11 ) ) then
    return null;
  end if;

  declare
    v_Numero number;
  begin
    v_Numero := to_number( i_Numero );
  exception
    when OTHERS then
      return null;
  end;

  -----------------------------------------------------------------------------
  -- Se o Numero tiver tamanho 11, entao os 2 ultimos sao os
  -- digitos verificadores. Retorna-los logo.
  -----------------------------------------------------------------------------
  if ( length( i_Numero ) = 11 ) then
    return substr( i_Numero, 10, 2 );
  end if;

  -----------------------------------------------------------------------------
  -- Foi dado numero com tamanho 9. Calcular o primeiro digito verificador.
  -----------------------------------------------------------------------------
  v_Digito1 :=
    10 * to_number( substr( i_Numero, 1, 1 ) ) +
     9 * to_number( substr( i_Numero, 2, 1 ) ) +
     8 * to_number( substr( i_Numero, 3, 1 ) ) +
     7 * to_number( substr( i_Numero, 4, 1 ) ) +
     6 * to_number( substr( i_Numero, 5, 1 ) ) +
     5 * to_number( substr( i_Numero, 6, 1 ) ) +
     4 * to_number( substr( i_Numero, 7, 1 ) ) +
     3 * to_number( substr( i_Numero, 8, 1 ) ) +
     2 * to_number( substr( i_Numero, 9, 1 ) );

  v_Digito1 := 11 - ( v_Digito1 mod 11 );

  v_Digito1 := case when v_Digito1 >= 10 then 0 else v_Digito1 end;

  -----------------------------------------------------------------------------
  -- Foi dado numero com tamanho 9. Calcular o segundo digito verificador.
  -----------------------------------------------------------------------------
  v_Digito2 :=
    11 * to_number( substr( i_Numero, 1, 1 ) ) +
    10 * to_number( substr( i_Numero, 2, 1 ) ) +
     9 * to_number( substr( i_Numero, 3, 1 ) ) +
     8 * to_number( substr( i_Numero, 4, 1 ) ) +
     7 * to_number( substr( i_Numero, 5, 1 ) ) +
     6 * to_number( substr( i_Numero, 6, 1 ) ) +
     5 * to_number( substr( i_Numero, 7, 1 ) ) +
     4 * to_number( substr( i_Numero, 8, 1 ) ) +
     3 * to_number( substr( i_Numero, 9, 1 ) );

  v_Digito2 := v_Digito2 + 2 * v_Digito1;

  v_Digito2 := 11 - ( v_Digito2 mod 11 );

  v_Digito2 := case when v_Digito2 >= 10 then 0 else v_Digito2 end;

  -----------------------------------------------------------------------------
  -- Retornar os dois digitos, concatenados.
  -----------------------------------------------------------------------------
  return to_char( v_Digito1 ) || to_char( v_Digito2 );

end ObterValidadores;

Python

def validar_cpf(cpf):
    digitos = [int(c) for c in cpf if c.isdigit()]
    if len(digitos) == 11:
        a,b,c,d,e,f,g,h,i,j,k = digitos
        numeros = [a,b,c,d,e,f,g,h,i]
        r = range(10, 1, -1)
        soma = sum([x * y for x, y in zip(numeros, r)])
        resto = soma % 11
        dv1 = (11 - resto if 11 - resto < 10 else 0)
        numeros = [a,b,c,d,e,f,g,h,i,dv1]
        r = range(11, 1, -1)
        soma = sum([x*y for x, y in zip(numeros, r)])
        resto = soma % 11
        dv2 = (11 - resto if 11 - resto < 10 else 0)
        return dv1 == j and dv2 == k
    return False

Ruby

    def validate_cpf(cpf)
      cpf = cpf.gsub(/[^0-9]/,"").scan(/./).map(&:to_i) rescue nil
      return false if cpf.try(:size) != 11
      dv = cpf.last(2)
      r1 = 10.downto(2).zip(cpf.first(9)).map{|x,y| x*y}.sum % 11
      r1 = (r1 < 2 ? 0 : 11 - r1)
      r2 = 11.downto(2).zip(cpf.first(10)).map{|x,y| x*y}.sum % 11
      r2 = (r2 < 2 ? 0 : 11 - r2)
      return r1 == dv[0] && r2 == dv[1]
    end

Haskell

import Data.Char

isCpfOk :: [Int] -> Bool
isCpfOk cpf = 
  let -- calcula primeiro digito
      digitos1 = take 9 cpf
      expr1 = (sum $ zipWith (*) digitos1 [10,9..2]) `mod` 11
      dv1 = if expr1 < 2 then 0 else 11-expr1

      -- calcula segundo digito
      digitos2 = digitos1 ++ [dv1]
      expr2 = (sum $ zipWith (*) digitos2 [11,10..2]) `mod` 11
      dv2 = if expr2 < 2 then 0 else 11-expr2
   in dv1 == cpf !! 9 && dv2 == cpf !! 10

main = do
  let cpf = "12345678909"
      digitos = (map digitToInt cpf)
      result = isCpfOk digitos
  putStrLn (show result)

VBA

    Public Function ValidarCPF(CPF As String) As Boolean
    Application.Volatile
    Dim vCPF As String
    Dim i, soma, dv1, dv2 As Long
    
    'Remove símbolos não numéricos
    vCPF = Replace(CPF, ".", "")
    vCPF = Replace(vCPF, "-", "")
    vCPF = Replace(vCPF, " ", "")
    vCPF = Format(CDbl(vCPF), "00000000000")
    
    'Invalida se achar mais de 11 caracteres
    If Len(vCPF) > 11 Then
        ValidarCPF = False
    Else
    
        'Calcula o 1º dígito
        soma = 0
        For i = 1 To 9
            soma = soma + Mid(vCPF, i, 1) * (11 - i)
        Next i
        dv1 = 11 - soma Mod 11
        If dv1 >= 10 Then dv1 = 0
        
        'Calcula o 2º dígito
        soma = 0
        For i = 1 To 9
            soma = soma + Mid(vCPF, i, 1) * (12 - i)
        Next i
        soma = soma + dv1 * 2
        dv2 = 11 - soma Mod 11
        If dv2 >= 10 Then dv2 = 0
        
        'Compara os dígitos recalculados com os do CPF inserido
        If dv1 = CInt(Mid(vCPF, 10, 1)) And dv2 = CInt(Mid(vCPF, 11, 1)) Then ValidarCPF = True Else ValidarCPF = False
    End If
    End Function

RfC: Grafia do título

@Dantadd:, @Usien6:, @Vtrnascimento:, @Arlenesong:, @Diego Queiroz:, @Marcos Elias de Oliveira Júnior:, @Edy7222:, @Capmo:, @Zoldyick:, @Micael petrucio:

Contexto

Caros colegas, não entendo o que atrai a um projeto colaborativo, como o nosso, um sujeito que estampa uma ode ao individualismo em sua PU. Mas o fato é que o colega Dantadd resolveu fazer uma alteração significativa^{[Δ44050420][Δ44050488]}, sem prévia discussão. Na sequência, tentei contato em sua PDU.^[Δ44051324] O editor me responde com um críptico laconismo,^[Δ44052001] ao qual ofereço réplica.^[Δ44055903] Face ao silêncio que se impôs na sequência, imagino que teria abandonado a causa e reverto suas edições.^{[Δ44084850][Δ44084867]} Ledo engano: ele parte para a guerra de edições.^{[Δ44092617][Δ44092624]} Já me sentido debochado pelo orgulhoso individualista, tento contato novamente,^[Δ44095977] mas continuo sendo ignorado.

Mérito

Discute-se se o título do verbete deve ser Cadastro de pessoas físicas, como está, em minúsculas; ou Cadastro de Pessoas Físicas, como sempre foi, em maiúsculas.

Requisição de comentários

Solicito, aos dez útimos editores registrados desse verbete, que discutam o mérito em forma de consenso ou votação.

--Usien6 D​ C​ E​ F 13h22min de 4 de dezembro de 2015 (UTC)

Cadastro de pessoas físicas

Cadastro de Pessoas Físicas

1. Essa é a forma oficial e universalmente aceita, enquanto aquela não se pode atestar. Ademais, harmoniza com Cadastro Nacional da Pessoa Jurídica e Classificação Nacional de Atividades Econômicas. --Usien6 D​ C​ E​ F 13h22min de 4 de dezembro de 2015 (UTC)

@Usien6: Essa votação é inapropriada. Em qualquer caso, primeiro expõem-se os argumentos a favor e contra e, depois, busca-se um consenso. Se houver argumentos válidos para ambos os lados, aí sim uma das opções é iniciar uma votação. De qualquer forma, eu prefiro a versão com letras minúsculas (a atual). De fato, é habitual em várias línguas deixar em maiúsculas as letras que compõem uma sigla, com o intuito de deixar claro como a sigla foi formada, mas, na minha opinião, essa capitalização é desnecessária aqui. Infelizmente, a Wikipédia:Convenção de nomenclatura#Uso de maiúsculas não é muito clara sobre esse assunto. --Diego Queiroz (discussão) 12h54min de 25 de dezembro de 2015 (UTC)